text:
package fr.lteconsulting.pomexplorer.changes;

import fr.lteconsulting.pomexplorer.GAV;
import fr.lteconsulting.pomexplorer.PomSection;
import fr.lteconsulting.pomexplorer.Project;
import fr.lteconsulting.pomexplorer.depanalyze.GavLocation;

public class GavChange extends Change<GavLocation>
{
    private final GAV newGav;

    public GavChange(Project project, PomSection pomSection, GAV gav, GAV newGav)
    {
        this(new GavLocation(project, pomSection, gav), newGav);
    }

    public GavChange(GavLocation location, GAV newGav)
    {
        super(location);
        this.newGav = newGav;
    }

    public GAV getNewGav()
    {
        return newGav;
    }

    @Override
    public String toString()
    {
        return super.toString() + "change to: " + newGav + "

";
    }

    @Override
    public int hashCode()
    {
        final int prime = 31;
        int result = super.hashCode();
        result = prime * result + ((newGav == null) ? 0 : newGav.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj)
    {
        if (this == obj)
            return true;
        if (!super.equals(obj))
            return false;
        if (getClass() != obj.getClass())
            return false;
        GavChange other = (GavChange) obj;
        if (newGav == null)
        {
            if (other.newGav != null)
                return false;
        }
        else if (!newGav.equals(other.newGav))
            return false;
        return true;
    }
}

redpajama_set_name: RedPajamaGithub


text: all: ; @echo Use a GNU-compatible make, e.g. gmake


text:
namespace bpftrace {

FakeMap::FakeMap(const std::string &name,
                 const SizedType &type,
                 const MapKey &key,
                 int min,
                 int max,
                 int step,
                 int max_entries)
    : IMap(name, type, key, min, max, step, max_entries)
{
}

FakeMap::FakeMap(const std::string &name,
                 libbpf::bpf_map_type type,
                 int key_size,
                 int value_size,
                 int max_entries,
                 int flags)
    : IMap(name, type, key_size, value_size, max_entries, flags)
{
}

FakeMap::FakeMap(const SizedType &type) : IMap(type)
{
}

FakeMap::FakeMap(libbpf::bpf_map_type map_type) : IMap(map_type)
{
}

} // namespace bpftrace


text:
<!DOCTYPE html>
<!--
Copyright (c) 2015 The Chromium Authors. All rights reserved.
Use of this source code is governed by a BSD-style license that can be
found in the LICENSE file.
-->

<link rel="import" href="/tracing/base/event.html">
<link rel="import" href="/tracing/base/utils.html">

<script>
'use strict';

/**
 * @fileoverview Some generic slice titles appear very frequently in traces,
 * like MessageLoop::RunTask. Some of these slices have arguments that give
 * useful context. This class combine such arguments with the slice title to
 * generate a more useful title.
 */
tr.exportTo('tr.e.chrome', function() {
  function SliceTitleFixer() {
  }

  // AsyncSlice uses virtual functions to accomplish something similar to what
  // we're doing here. If this function ever becomes too complex we may consider
  // using a similar pattern.
  SliceTitleFixer.fromEvent = function(event) {
    if (event.args && event.args.src_func) {
      return event.title + ' <- ' + event.args.src_func;
    }
    return event.title;
  };

  return {
    SliceTitleFixer,
  };
});
</script>


text:
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

class Main {
  @NotNull
  private Object test1(@NotNull Object defVal, @Nullable final Object val) {
    return defVal;
  }
  @NotNull
  private Object test11(@NotNull Object defVal, @Nullable final Object val) {
    if (val != null) {
      return val;
    }
    return defVal;
  }
  @NotNull
  private Object test5(@NotNull Object defVal, @Nullable final Object val) {
    if (defVal == val) {
      return val;
    }
    return defVal;
  }
  @NotNull
  private Object test6(@NotNull Object defVal, @Nullable final Object val) {
    if (val == defVal) {
      return val;
    }
    return defVal;
  }
  @NotNull
  private Object test7(@NotNull Object defVal, @Nullable final Object val) {
    if (val.<warning descr="Method invocation 'equals' may produce 'java.lang.NullPointerException'">equals</warning>(defVal)) {
      return defVal;
    }
    return defVal;
  }
  @NotNull
  private Object test8(@NotNull Object defVal, @Nullable final Object val) {
    if (defVal.equals(val)) {
      return val;
    }
    return defVal;
  }
  @NotNull private Object test9(@NotNull Object defVal, @Nullable final Object val) {
    if (equals(val)) {
      return val;
    }
    return defVal;
  }
  @NotNull private Object test10(@NotNull Object defVal, @Nullable final Object val) {
    if (val != null) {
      return val;
    }
    if (<warning descr="Condition 'defVal.equals(val)' is always 'false'">defVal.equals(val)</warning>) {
      return val;
    }
    return defVal;
  }

  @NotNull
  private static Object test(@NotNull Object defVal, @Nullable final Object val) {
    if (val != null) {
      return val;
    }
    if (<warning descr="Condition 'defVal == val' is always 'false'">defVal == val</warning>) {
      return val;
    }
    if (<warning descr="Condition 'val == defVal' is always 'false'">val == defVal</warning>) {
      return val;
    }
    if (<warning descr="Condition 'defVal.equals(val)' is always 'false'">defVal.equals(val)</warning>) {
      return val;
    }
    return defVal;
  }

  private static void test2(@NotNull Object defVal, @Nullable final Object val) {
    if(val == defVal) {
      if(<warning descr="Condition 'val == null' is always 'false'">val == null</warning>) {
        System.out.println("oops");
      }
    }
  }

  private void test3(@Nullable Object val) {
    if(<warning descr="Condition 'val != this || val != null' is always 'true'">val != this || <warning descr="Condition 'val != null' is always 'true' when reached">val != null</warning></warning>) {
      System.out.println("never happens");
    }
  }

}


text:
==============
Test Utilities
==============

``test_utils`` is a grab-bag of testing utilities that are pretty specific to
our Django, Jinja2, and nose setup.

See the docs at http://jbalogh.me/projects/test-utils.


text:
General

Password

          <ng-include src="'wallet/templates/wallet-settings-partial-general.html'"></ng-include>

          <ng-include src="'wallet/templates/wallet-settings-partial-passcode.html'"></ng-include>


text:
package templates

const networkTpl = `
{{ if .IsBootstrap }}

# wait when apiserver is up and running

sudo kubectl get po
until $([  $? -lt 1 ]); do sudo kubectl get po; sleep 5; done

{{ if eq .NetworkProvider "Flannel" }}
sudo bash -c 'cat << EOF > flannel.yaml
---
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: flannel
rules:
  - apiGroups:
      - ""
    resources:
      - pods
    verbs:
      - get
  - apiGroups:
      - ""
    resources:
      - nodes
    verbs:
      - list
      - watch
  - apiGroups:
      - ""
    resources:
      - nodes/status
    verbs:
      - patch
---
kind: ClusterRoleBinding
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: flannel
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: flannel
subjects:
- kind: ServiceAccount
  name: flannel
  namespace: kube-system
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: flannel
  namespace: kube-system
---
kind: ConfigMap
apiVersion: v1
metadata:
  name: kube-flannel-cfg
  namespace: kube-system
  labels:
    tier: node
    app: flannel
data:
  cni-conf.json: |
    {
      "name": "cbr0",
      "plugins": [
        {
          "type": "flannel",
          "delegate": {
            "hairpinMode": true,
            "isDefaultGateway": true
          }
        },
        {
          "type": "portmap",
          "capabilities": {
            "portMappings": true
          }
        }
      ]
    }
  net-conf.json: |
    {
      "Network": "{{ .CIDR }}",
      "Backend": {
        "Type": "vxlan"
      }
    }
---
apiVersion: extensions/v1beta1
kind: DaemonSet
metadata:
  name: kube-flannel-ds-amd64
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      hostNetwork: true
      nodeSelector:
        beta.kubernetes.io/arch: amd64
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay.io/coreos/flannel:v0.10.0-amd64
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay.io/coreos/flannel:v0.10.0-amd64
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: true
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run
        - name: cni
          hostPath:
            path: /etc/cni/net.d
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg
---
apiVersion: extensions/v1beta1
kind: DaemonSet
metadata:
  name: kube-flannel-ds-arm64
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      hostNetwork: true
      nodeSelector:
        beta.kubernetes.io/arch: arm64
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay.io/coreos/flannel:v0.10.0-arm64
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay.io/coreos/flannel:v0.10.0-arm64
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: true
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run
        - name: cni
          hostPath:
            path: /etc/cni/net.d
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg
---
apiVersion: extensions/v1beta1
kind: DaemonSet
metadata:
  name: kube-flannel-ds-arm
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      hostNetwork: true
      nodeSelector:
        beta.kubernetes.io/arch: arm
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay.io/coreos/flannel:v0.10.0-arm
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay.io/coreos/flannel:v0.10.0-arm
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: true
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run
        - name: cni
          hostPath:
            path: /etc/cni/net.d
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg
---
apiVersion: extensions/v1beta1
kind: DaemonSet
metadata:
  name: kube-flannel-ds-ppc64le
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      hostNetwork: true
      nodeSelector:
        beta.kubernetes.io/arch: ppc64le
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay.io/coreos/flannel:v0.10.0-ppc64le
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay.io/coreos/flannel:v0.10.0-ppc64le
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: true
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run
        - name: cni
          hostPath:
            path: /etc/cni/net.d
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg
---
apiVersion: extensions/v1beta1
kind: DaemonSet
metadata:
  name: kube-flannel-ds-s390x
  namespace: kube-system
  labels:
    tier: node
    app: flannel
spec:
  template:
    metadata:
      labels:
        tier: node
        app: flannel
    spec:
      hostNetwork: true
      nodeSelector:
        beta.kubernetes.io/arch: s390x
      tolerations:
      - operator: Exists
        effect: NoSchedule
      serviceAccountName: flannel
      initContainers:
      - name: install-cni
        image: quay.io/coreos/flannel:v0.10.0-s390x
        command:
        - cp
        args:
        - -f
        - /etc/kube-flannel/cni-conf.json
        - /etc/cni/net.d/10-flannel.conflist
        volumeMounts:
        - name: cni
          mountPath: /etc/cni/net.d
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      containers:
      - name: kube-flannel
        image: quay.io/coreos/flannel:v0.10.0-s390x
        command:
        - /opt/bin/flanneld
        args:
        - --ip-masq
        - --kube-subnet-mgr
        resources:
          requests:
            cpu: "100m"
            memory: "50Mi"
          limits:
            cpu: "100m"
            memory: "50Mi"
        securityContext:
          privileged: true
        env:
        - name: POD_NAME
          valueFrom:
            fieldRef:
              fieldPath: metadata.name
        - name: POD_NAMESPACE
          valueFrom:
            fieldRef:
              fieldPath: metadata.namespace
        volumeMounts:
        - name: run
          mountPath: /run
        - name: flannel-cfg
          mountPath: /etc/kube-flannel/
      volumes:
        - name: run
          hostPath:
            path: /run
        - name: cni
          hostPath:
            path: /etc/cni/net.d
        - name: flannel-cfg
          configMap:
            name: kube-flannel-cfg
EOF'

sudo kubectl create -f flannel.yaml
{{ end }}

{{ if eq .NetworkProvider "Calico" }}
sudo bash -c 'cat << EOF > rbac-kdd.yaml
kind: ClusterRole
apiVersion: rbac.authorization.k8s.io/v1beta1
metadata:
  name: calico-node
rules:
  - apiGroups: [""]
    resources:
      - namespaces
      - serviceaccounts
    verbs:
      - get
      - list
      - watch
  - apiGroups: [""]
    resources:
      - pods/status
    verbs:
      - patch
  - apiGroups: [""]
    resources:
      - pods
    verbs:
      - get
      - list
      - watch
  - apiGroups: [""]
    resources:
      - services
    verbs:
      - get
  - apiGroups: [""]
    resources:
      - endpoints
    verbs:
      - get
  - apiGroups: [""]
    resources:
      - nodes
    verbs:
      - get
      - list
      - update
      - watch
  - apiGroups: ["extensions"]
    resources:
      - networkpolicies
    verbs:
      - get
      - list
      - watch
  - apiGroups: ["networking.k8s.io"]
    resources:
      - networkpolicies
    verbs:
      - watch
      - list
  - apiGroups: ["crd.projectcalico.org"]
    resources:
      - globalfelixconfigs
      - felixconfigurations
      - bgppeers
      - globalbgpconfigs
      - bgpconfigurations
      - ippools
      - globalnetworkpolicies
      - globalnetworksets
      - networkpolicies
      - clusterinformations
      - hostendpoints
    verbs:
      - create
      - get
      - list
      - update
      - watch

---

apiVersion: rbac.authorization.k8s.io/v1beta1
kind: ClusterRoleBinding
metadata:
  name: calico-node
roleRef:
  apiGroup: rbac.authorization.k8s.io
  kind: ClusterRole
  name: calico-node
subjects:
- kind: ServiceAccount
  name: calico-node
  namespace: kube-system
EOF'

sudo kubectl create -f rbac-kdd.yaml

sudo bash -c 'cat << EOF > calico.yaml
kind: ConfigMap
apiVersion: v1
metadata:
  name: calico-config
  namespace: kube-system
data:
  typha_service_name: "none"
  calico_backend: "bird"

  veth_mtu: "1440"

  cni_network_config: |-
    {
      "name": "k8s-pod-network",
      "cniVersion": "0.3.0",
      "plugins": [
        {
          "type": "calico",
          "log_level": "info",
          "datastore_type": "kubernetes",
          "nodename": "__KUBERNETES_NODE_NAME__",
          "mtu": __CNI_MTU__,
          "ipam": {
            "type": "host-local",
            "subnet": "usePodCidr"
          },
          "policy": {
              "type": "k8s"
          },
          "kubernetes": {
              "kubeconfig": "__KUBECONFIG_FILEPATH__"
          }
        },
        {
          "type": "portmap",
          "snat": true,
          "capabilities": {"portMappings": true}
        }
      ]
    }
---
apiVersion: v1
kind: Service
metadata:
  name: calico-typha
  namespace: kube-system
  labels:
    k8s-app: calico-typha
spec:
  ports:
    - port: 5473
      protocol: TCP
      targetPort: calico-typha
      name: calico-typha
  selector:
    k8s-app: calico-typha

---
apiVersion: apps/v1beta1
kind: Deployment
metadata:
  name: calico-typha
  namespace: kube-system
  labels:
    k8s-app: calico-typha
spec:
  replicas: 0
  revisionHistoryLimit: 2
  template:
    metadata:
      labels:
        k8s-app: calico-typha
    spec:
      nodeSelector:
        beta.kubernetes.io/os: linux
      hostNetwork: true
      tolerations:
        # Mark the pod as a critical add-on for rescheduling.
        - key: CriticalAddonsOnly
          operator: Exists
      serviceAccountName: calico-node
      containers:
      - image: calico/typha:v3.3.2
        name: calico-typha
        ports:
        - containerPort: 5473
          name: calico-typha
          protocol: TCP
        env:
          - name: TYPHA_LOGSEVERITYSCREEN
            value: "info"
          - name: TYPHA_LOGFILEPATH
            value: "none"
          - name: TYPHA_LOGSEVERITYSYS
            value: "none"
          - name: TYPHA_CONNECTIONREBALANCINGMODE
            value: "kubernetes"
          - name: TYPHA_DATASTORETYPE
            value: "kubernetes"
          - name: TYPHA_HEALTHENABLED
            value: "true"
        livenessProbe:
          exec:
            command:
            - calico-typha
            - check
            - liveness
          periodSeconds: 30
          initialDelaySeconds: 30
        readinessProbe:
          exec:
            command:
            - calico-typha
            - check
            - readiness
          periodSeconds: 10

---
apiVersion: policy/v1beta1
kind: PodDisruptionBudget
metadata:
  name: calico-typha
  namespace: kube-system
  labels:
    k8s-app: calico-typha
spec:
  maxUnavailable: 1
  selector:
    matchLabels:
      k8s-app: calico-typha

---
kind: DaemonSet
apiVersion: extensions/v1beta1
metadata:
  name: calico-node
  namespace: kube-system
  labels:
    k8s-app: calico-node
spec:
  selector:
    matchLabels:
      k8s-app: calico-node
  updateStrategy:
    type: RollingUpdate
    rollingUpdate:
      maxUnavailable: 1
  template:
    metadata:
      labels:
        k8s-app: calico-node
      annotations:
        scheduler.alpha.kubernetes.io/critical-pod: ""
    spec:
      nodeSelector:
        beta.kubernetes.io/os: linux
      hostNetwork: true
      tolerations:
        - effect: NoSchedule
          operator: Exists
        # Mark the pod as a critical add-on for rescheduling.
        - key: CriticalAddonsOnly
          operator: Exists
        - effect: NoExecute
          operator: Exists
      serviceAccountName: calico-node
      terminationGracePeriodSeconds: 0
      containers:
        - name: calico-node
          image: calico/node:v3.3.2
          env:
            - name: DATASTORE_TYPE
              value: "kubernetes"
            - name: FELIX_TYPHAK8SSERVICENAME
              valueFrom:
                configMapKeyRef:
                  name: calico-config
                  key: typha_service_name
            - name: WAIT_FOR_DATASTORE
              value: "true"
            - name: NODENAME
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
            - name: CALICO_NETWORKING_BACKEND
              valueFrom:
                configMapKeyRef:
                  name: calico-config
                  key: calico_backend
            - name: CLUSTER_TYPE
              value: "k8s,bgp"
            - name: IP
              value: "autodetect"
            - name: CALICO_IPV4POOL_IPIP
              value: "Always"
            - name: FELIX_IPINIPMTU
              valueFrom:
                configMapKeyRef:
                  name: calico-config
                  key: veth_mtu
            - name: CALICO_IPV4POOL_CIDR
              value: "{{ .CIDR }}"
            - name: CALICO_DISABLE_FILE_LOGGING
              value: "true"
            - name: FELIX_DEFAULTENDPOINTTOHOSTACTION
              value: "ACCEPT"
            - name: FELIX_IPV6SUPPORT
              value: "false"
            - name: FELIX_LOGSEVERITYSCREEN
              value: "info"
            - name: FELIX_HEALTHENABLED
              value: "true"
          securityContext:
            privileged: true
          resources:
            requests:
              cpu: 250m
          livenessProbe:
            httpGet:
              path: /liveness
              port: 9099
              host: localhost
            periodSeconds: 10
            initialDelaySeconds: 10
            failureThreshold: 6
          readinessProbe:
            exec:
              command:
              - /bin/calico-node
              - -bird-ready
              - -felix-ready
            periodSeconds: 10
          volumeMounts:
            - mountPath: /lib/modules
              name: lib-modules
              readOnly: true
            - mountPath: /run/xtables.lock
              name: xtables-lock
              readOnly: false
            - mountPath: /var/run/calico
              name: var-run-calico
              readOnly: false
            - mountPath: /var/lib/calico
              name: var-lib-calico
              readOnly: false
        - name: install-cni
          image: calico/cni:v3.3.2
          command: ["/install-cni.sh"]
          env:
            - name: CNI_CONF_NAME
              value: "10-calico.conflist"
            - name: KUBERNETES_NODE_NAME
              valueFrom:
                fieldRef:
                  fieldPath: spec.nodeName
            - name: CNI_NETWORK_CONFIG
              valueFrom:
                configMapKeyRef:
                  name: calico-config
                  key: cni_network_config
            - name: CNI_MTU
              valueFrom:
                configMapKeyRef:
                  name: calico-config
                  key: veth_mtu
          volumeMounts:
            - mountPath: /host/opt/cni/bin
              name: cni-bin-dir
            - mountPath: /host/etc/cni/net.d
              name: cni-net-dir
      volumes:
        # Used by calico/node.
        - name: lib-modules
          hostPath:
            path: /lib/modules
        - name: var-run-calico
          hostPath:
            path: /var/run/calico
        - name: var-lib-calico
          hostPath:
            path: /var/lib/calico
        - name: xtables-lock
          hostPath:
            path: /run/xtables.lock
            type: FileOrCreate
        - name: cni-bin-dir
          hostPath:
            path: /opt/cni/bin
        - name: cni-net-dir
          hostPath:
            path: /etc/cni/net.d
---
apiVersion: v1
kind: ServiceAccount
metadata:
  name: calico-node
  namespace: kube-system

---
apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
   name: felixconfigurations.crd.projectcalico.org
spec:
  scope: Cluster
  group: crd.projectcalico.org
  version: v1
  names:
    kind: FelixConfiguration
    plural: felixconfigurations
    singular: felixconfiguration
---

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: bgppeers.crd.projectcalico.org
spec:
  scope: Cluster
  group: crd.projectcalico.org
  version: v1
  names:
    kind: BGPPeer
    plural: bgppeers
    singular: bgppeer

---

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: bgpconfigurations.crd.projectcalico.org
spec:
  scope: Cluster
  group: crd.projectcalico.org
  version: v1
  names:
    kind: BGPConfiguration
    plural: bgpconfigurations
    singular: bgpconfiguration

---

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: ippools.crd.projectcalico.org
spec:
  scope: Cluster
  group: crd.projectcalico.org
  version: v1
  names:
    kind: IPPool
    plural: ippools
    singular: ippool

---

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: hostendpoints.crd.projectcalico.org
spec:
  scope: Cluster
  group: crd.projectcalico.org
  version: v1
  names:
    kind: HostEndpoint
    plural: hostendpoints
    singular: hostendpoint

---

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: clusterinformations.crd.projectcalico.org
spec:
  scope: Cluster
  group: crd.projectcalico.org
  version: v1
  names:
    kind: ClusterInformation
    plural: clusterinformations
    singular: clusterinformation

---

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: globalnetworkpolicies.crd.projectcalico.org
spec:
  scope: Cluster
  group: crd.projectcalico.org
  version: v1
  names:
    kind: GlobalNetworkPolicy
    plural: globalnetworkpolicies
    singular: globalnetworkpolicy

---

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: globalnetworksets.crd.projectcalico.org
spec:
  scope: Cluster
  group: crd.projectcalico.org
  version: v1
  names:
    kind: GlobalNetworkSet
    plural: globalnetworksets
    singular: globalnetworkset

---

apiVersion: apiextensions.k8s.io/v1beta1
kind: CustomResourceDefinition
metadata:
  name: networkpolicies.crd.projectcalico.org
spec:
  scope: Namespaced
  group: crd.projectcalico.org
  version: v1
  names:
    kind: NetworkPolicy
    plural: networkpolicies
    singular: networkpolicy
EOF'
sudo kubectl create -f calico.yaml
{{ end }}

{{ if eq .NetworkProvider "Weave" }}
sudo bash -c "cat << EOF > weave.yaml
apiVersion: v1
kind: List
items:
  - apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: weave-net
      annotations:
        cloud.weave.works/launcher-info: |-
          {
            'original-request': {
              'url': '/k8s/v1.10/net.yaml?k8s-version=Q2xpZW50IFZlcnNpb246IHZlcnNpb24uSW5mb3tNYWpvcjoiMSIsIE1pbm9yOiIxMCIsIEdpdFZlcnNpb246InYxLjEwLjciLCBHaXRDb21taXQ6IjBjMzhjMzYyNTExYjIwYTA5OGQ3Y2Q4NTVmMTMxNGRhZDkyYzI3ODAiLCBHaXRUcmVlU3RhdGU6ImNsZWFuIiwgQnVpbGREYXRlOiIyMDE4LTA4LTIwVDEwOjA5OjAzWiIsIEdvVmVyc2lvbjoiZ28xLjkuMyIsIENvbXBpbGVyOiJnYyIsIFBsYXRmb3JtOiJsaW51eC9hbWQ2NCJ9ClNlcnZlciBWZXJzaW9uOiB2ZXJzaW9uLkluZm97TWFqb3I6IjEiLCBNaW5vcjoiMTIiLCBHaXRWZXJzaW9uOiJ2MS4xMi40IiwgR2l0Q29tbWl0OiJmNDlmYTAyMmRiZTYzZmFhZmQwZGExMDZlZjdlMDVhMjk3MjFkM2YxIiwgR2l0VHJlZVN0YXRlOiJjbGVhbiIsIEJ1aWxkRGF0ZToiMjAxOC0xMi0xNFQwNjo1OTozN1oiLCBHb1ZlcnNpb246ImdvMS4xMC40IiwgQ29tcGlsZXI6ImdjIiwgUGxhdGZvcm06ImxpbnV4L2FtZDY0In0K',
              'date': 'Fri Mar 15 2019 15:27:35 GMT+0000 (UTC)'
            },
            'email-address': 'support@weave.works'
          }
      labels:
        name: weave-net
      namespace: kube-system
  - apiVersion: rbac.authorization.k8s.io/v1beta1
    kind: ClusterRole
    metadata:
      name: weave-net
      annotations:
        cloud.weave.works/launcher-info: |-
          {
            'original-request': {
              'url': '/k8s/v1.10/net.yaml?k8s-version=Q2xpZW50IFZlcnNpb246IHZlcnNpb24uSW5mb3tNYWpvcjoiMSIsIE1pbm9yOiIxMCIsIEdpdFZlcnNpb246InYxLjEwLjciLCBHaXRDb21taXQ6IjBjMzhjMzYyNTExYjIwYTA5OGQ3Y2Q4NTVmMTMxNGRhZDkyYzI3ODAiLCBHaXRUcmVlU3RhdGU6ImNsZWFuIiwgQnVpbGREYXRlOiIyMDE4LTA4LTIwVDEwOjA5OjAzWiIsIEdvVmVyc2lvbjoiZ28xLjkuMyIsIENvbXBpbGVyOiJnYyIsIFBsYXRmb3JtOiJsaW51eC9hbWQ2NCJ9ClNlcnZlciBWZXJzaW9uOiB2ZXJzaW9uLkluZm97TWFqb3I6IjEiLCBNaW5vcjoiMTIiLCBHaXRWZXJzaW9uOiJ2MS4xMi40IiwgR2l0Q29tbWl0OiJmNDlmYTAyMmRiZTYzZmFhZmQwZGExMDZlZjdlMDVhMjk3MjFkM2YxIiwgR2l0VHJlZVN0YXRlOiJjbGVhbiIsIEJ1aWxkRGF0ZToiMjAxOC0xMi0xNFQwNjo1OTozN1oiLCBHb1ZlcnNpb246ImdvMS4xMC40IiwgQ29tcGlsZXI6ImdjIiwgUGxhdGZvcm06ImxpbnV4L2FtZDY0In0K',
              'date': 'Fri Mar 15 2019 15:27:35 GMT+0000 (UTC)'
            },
            'email-address': 'support@weave.works'
          }
      labels:
        name: weave-net
    rules:
      - apiGroups:
          - ''
        resources:
          - pods
          - namespaces
          - nodes
        verbs:
          - get
          - list
          - watch
      - apiGroups:
          - networking.k8s.io
        resources:
          - networkpolicies
        verbs:
          - get
          - list
          - watch
      - apiGroups:
          - ''
        resources:
          - nodes/status
        verbs:
          - patch
          - update
  - apiVersion: rbac.authorization.k8s.io/v1beta1
    kind: ClusterRoleBinding
    metadata:
      name: weave-net
      annotations:
        cloud.weave.works/launcher-info: |-
          {
            'original-request': {
              'url': '/k8s/v1.10/net.yaml?k8s-version=Q2xpZW50IFZlcnNpb246IHZlcnNpb24uSW5mb3tNYWpvcjoiMSIsIE1pbm9yOiIxMCIsIEdpdFZlcnNpb246InYxLjEwLjciLCBHaXRDb21taXQ6IjBjMzhjMzYyNTExYjIwYTA5OGQ3Y2Q4NTVmMTMxNGRhZDkyYzI3ODAiLCBHaXRUcmVlU3RhdGU6ImNsZWFuIiwgQnVpbGREYXRlOiIyMDE4LTA4LTIwVDEwOjA5OjAzWiIsIEdvVmVyc2lvbjoiZ28xLjkuMyIsIENvbXBpbGVyOiJnYyIsIFBsYXRmb3JtOiJsaW51eC9hbWQ2NCJ9ClNlcnZlciBWZXJzaW9uOiB2ZXJzaW9uLkluZm97TWFqb3I6IjEiLCBNaW5vcjoiMTIiLCBHaXRWZXJzaW9uOiJ2MS4xMi40IiwgR2l0Q29tbWl0OiJmNDlmYTAyMmRiZTYzZmFhZmQwZGExMDZlZjdlMDVhMjk3MjFkM2YxIiwgR2l0VHJlZVN0YXRlOiJjbGVhbiIsIEJ1aWxkRGF0ZToiMjAxOC0xMi0xNFQwNjo1OTozN1oiLCBHb1ZlcnNpb246ImdvMS4xMC40IiwgQ29tcGlsZXI6ImdjIiwgUGxhdGZvcm06ImxpbnV4L2FtZDY0In0K',
              'date': 'Fri Mar 15 2019 15:27:35 GMT+0000 (UTC)'
            },
            'email-address': 'support@weave.works'
          }
      labels:
        name: weave-net
    roleRef:
      kind: ClusterRole
      name: weave-net
      apiGroup: rbac.authorization.k8s.io
    subjects:
      - kind: ServiceAccount
        name: weave-net
        namespace: kube-system
  - apiVersion: rbac.authorization.k8s.io/v1beta1
    kind: Role
    metadata:
      name: weave-net
      annotations:
        cloud.weave.works/launcher-info: |-
          {
            'original-request': {
              'url': '/k8s/v1.10/net.yaml?k8s-version=Q2xpZW50IFZlcnNpb246IHZlcnNpb24uSW5mb3tNYWpvcjoiMSIsIE1pbm9yOiIxMCIsIEdpdFZlcnNpb246InYxLjEwLjciLCBHaXRDb21taXQ6IjBjMzhjMzYyNTExYjIwYTA5OGQ3Y2Q4NTVmMTMxNGRhZDkyYzI3ODAiLCBHaXRUcmVlU3RhdGU6ImNsZWFuIiwgQnVpbGREYXRlOiIyMDE4LTA4LTIwVDEwOjA5OjAzWiIsIEdvVmVyc2lvbjoiZ28xLjkuMyIsIENvbXBpbGVyOiJnYyIsIFBsYXRmb3JtOiJsaW51eC9hbWQ2NCJ9ClNlcnZlciBWZXJzaW9uOiB2ZXJzaW9uLkluZm97TWFqb3I6IjEiLCBNaW5vcjoiMTIiLCBHaXRWZXJzaW9uOiJ2MS4xMi40IiwgR2l0Q29tbWl0OiJmNDlmYTAyMmRiZTYzZmFhZmQwZGExMDZlZjdlMDVhMjk3MjFkM2YxIiwgR2l0VHJlZVN0YXRlOiJjbGVhbiIsIEJ1aWxkRGF0ZToiMjAxOC0xMi0xNFQwNjo1OTozN1oiLCBHb1ZlcnNpb246ImdvMS4xMC40IiwgQ29tcGlsZXI6ImdjIiwgUGxhdGZvcm06ImxpbnV4L2FtZDY0In0K',
              'date': 'Fri Mar 15 2019 15:27:35 GMT+0000 (UTC)'
            },
            'email-address': 'support@weave.works'
          }
      labels:
        name: weave-net
      namespace: kube-system
    rules:
      - apiGroups:
          - ''
        resourceNames:
          - weave-net
        resources:
          - configmaps
        verbs:
          - get
          - update
      - apiGroups:
          - ''
        resources:
          - configmaps
        verbs:
          - create
  - apiVersion: rbac.authorization.k8s.io/v1beta1
    kind: RoleBinding
    metadata:
      name: weave-net
      annotations:
        cloud.weave.works/launcher-info: |-
          {
            'original-request': {
              'url': '/k8s/v1.10/net.yaml?k8s-version=Q2xpZW50IFZlcnNpb246IHZlcnNpb24uSW5mb3tNYWpvcjoiMSIsIE1pbm9yOiIxMCIsIEdpdFZlcnNpb246InYxLjEwLjciLCBHaXRDb21taXQ6IjBjMzhjMzYyNTExYjIwYTA5OGQ3Y2Q4NTVmMTMxNGRhZDkyYzI3ODAiLCBHaXRUcmVlU3RhdGU6ImNsZWFuIiwgQnVpbGREYXRlOiIyMDE4LTA4LTIwVDEwOjA5OjAzWiIsIEdvVmVyc2lvbjoiZ28xLjkuMyIsIENvbXBpbGVyOiJnYyIsIFBsYXRmb3JtOiJsaW51eC9hbWQ2NCJ9ClNlcnZlciBWZXJzaW9uOiB2ZXJzaW9uLkluZm97TWFqb3I6IjEiLCBNaW5vcjoiMTIiLCBHaXRWZXJzaW9uOiJ2MS4xMi40IiwgR2l0Q29tbWl0OiJmNDlmYTAyMmRiZTYzZmFhZmQwZGExMDZlZjdlMDVhMjk3MjFkM2YxIiwgR2l0VHJlZVN0YXRlOiJjbGVhbiIsIEJ1aWxkRGF0ZToiMjAxOC0xMi0xNFQwNjo1OTozN1oiLCBHb1ZlcnNpb246ImdvMS4xMC40IiwgQ29tcGlsZXI6ImdjIiwgUGxhdGZvcm06ImxpbnV4L2FtZDY0In0K',
              'date': 'Fri Mar 15 2019 15:27:35 GMT+0000 (UTC)'
            },
            'email-address': 'support@weave.works'
          }
      labels:
        name: weave-net
      namespace: kube-system
    roleRef:
      kind: Role
      name: weave-net
      apiGroup: rbac.authorization.k8s.io
    subjects:
      - kind: ServiceAccount
        name: weave-net
        namespace: kube-system
  - apiVersion: extensions/v1beta1
    kind: DaemonSet
    metadata:
      name: weave-net
      annotations:
        cloud.weave.works/launcher-info: |-
          {
            'original-request': {
              'url': '/k8s/v1.10/net.yaml?k8s-version=Q2xpZW50IFZlcnNpb246IHZlcnNpb24uSW5mb3tNYWpvcjoiMSIsIE1pbm9yOiIxMCIsIEdpdFZlcnNpb246InYxLjEwLjciLCBHaXRDb21taXQ6IjBjMzhjMzYyNTExYjIwYTA5OGQ3Y2Q4NTVmMTMxNGRhZDkyYzI3ODAiLCBHaXRUcmVlU3RhdGU6ImNsZWFuIiwgQnVpbGREYXRlOiIyMDE4LTA4LTIwVDEwOjA5OjAzWiIsIEdvVmVyc2lvbjoiZ28xLjkuMyIsIENvbXBpbGVyOiJnYyIsIFBsYXRmb3JtOiJsaW51eC9hbWQ2NCJ9ClNlcnZlciBWZXJzaW9uOiB2ZXJzaW9uLkluZm97TWFqb3I6IjEiLCBNaW5vcjoiMTIiLCBHaXRWZXJzaW9uOiJ2MS4xMi40IiwgR2l0Q29tbWl0OiJmNDlmYTAyMmRiZTYzZmFhZmQwZGExMDZlZjdlMDVhMjk3MjFkM2YxIiwgR2l0VHJlZVN0YXRlOiJjbGVhbiIsIEJ1aWxkRGF0ZToiMjAxOC0xMi0xNFQwNjo1OTozN1oiLCBHb1ZlcnNpb246ImdvMS4xMC40IiwgQ29tcGlsZXI6ImdjIiwgUGxhdGZvcm06ImxpbnV4L2FtZDY0In0K',
              'date': 'Fri Mar 15 2019 15:27:35 GMT+0000 (UTC)'
            },
            'email-address': 'support@weave.works'
          }
      labels:
        name: weave-net
      namespace: kube-system
    spec:
      minReadySeconds: 5
      template:
        metadata:
          labels:
            name: weave-net
        spec:
          containers:
            - name: weave
              command:
                - /home/weave/launch.sh
              env:
                - name: HOSTNAME
                  valueFrom:
                    fieldRef:
                      apiVersion: v1
                      fieldPath: spec.nodeName
              image: 'docker.io/weaveworks/weave-kube:2.5.1'
              readinessProbe:
                httpGet:
                  host: 127.0.0.1
                  path: /status
                  port: 6784
              resources:
                requests:
                  cpu: 10m
              securityContext:
                privileged: true
              volumeMounts:
                - name: weavedb
                  mountPath: /weavedb
                - name: cni-bin
                  mountPath: /host/opt
                - name: cni-bin2
                  mountPath: /host/home
                - name: cni-conf
                  mountPath: /host/etc
                - name: dbus
                  mountPath: /host/var/lib/dbus
                - name: lib-modules
                  mountPath: /lib/modules
                - name: xtables-lock
                  mountPath: /run/xtables.lock
            - name: weave-npc
              env:
                - name: HOSTNAME
                  valueFrom:
                    fieldRef:
                      apiVersion: v1
                      fieldPath: spec.nodeName
              image: 'docker.io/weaveworks/weave-npc:2.5.1'
              resources:
                requests:
                  cpu: 10m
              securityContext:
                privileged: true
              volumeMounts:
                - name: xtables-lock
                  mountPath: /run/xtables.lock
          hostNetwork: true
          hostPID: true
          restartPolicy: Always
          securityContext:
            seLinuxOptions: {}
          serviceAccountName: weave-net
          tolerations:
            - effect: NoSchedule
              operator: Exists
          volumes:
            - name: weavedb
              hostPath:
                path: /var/lib/weave
            - name: cni-bin
              hostPath:
                path: /opt
            - name: cni-bin2
              hostPath:
                path: /home
            - name: cni-conf
              hostPath:
                path: /etc
            - name: dbus
              hostPath:
                path: /var/lib/dbus
            - name: lib-modules
              hostPath:
                path: /lib/modules
            - name: xtables-lock
              hostPath:
                path: /run/xtables.lock
                type: FileOrCreate
      updateStrategy:
        type: RollingUpdate
EOF"

sudo kubectl create -f weave.yaml
{{ end }}
{{ end }}
`


text:
<PackageItem xmlns:tcm="http://www.tridion.com/ContentManager/5.0" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns="http://www.sdltridion.com/ContentManager/ImportExport/Package/2013">
  <Data>
    <tcm:Data>
      <tcm:Title>Experience Optimization</tcm:Title>
      <tcm:LinkedSchema xlink:type="simple" xlink:title="" xlink:href="tcm:0-0-0" IsMandatory="false" />
      <tcm:MetadataSchema xlink:type="simple" xlink:title="" xlink:href="tcm:0-0-0" />
      <tcm:Metadata />
    </tcm:Data>
  </Data>
  <Dependencies>
    <Dependency dependencyType="Publication" itemUrl="/webdav/000%20Empty" linkName="LocationInfo/ContextRepository" />
    <Dependency dependencyType="OrganizationalItemFolder" itemUrl="/webdav/000%20Empty/Building%20Blocks/Default%20Templates" linkName="LocationInfo/OrganizationalItem" />
  </Dependencies>
</PackageItem>


text:
'use strict';

const inspection = require('inspection');

module.exports.handler = function(event, context, cb) {
  const inspect = inspection();
  console.log(JSON.stringify(inspect));
  cb(null, inspect);
};


text: $('body').simplicityState();


text:
package nz.ac.waikato.jdsl.core.ref;

import nz.ac.waikato.jdsl.core.api.*;

/**
 * A Sequence based on a doubly-linked-list implementation.

 *
 * It incorporates the iterator caching optimization:

 * calls to iterator() are amortized
 * O(n/k) time if called k times between modifications of the sequence.
 * This is accomplished by making a list of
 * the positions of the sequence whenever iterating through
 * the list is necessary, and using it until there is a modification
 * to the Sequence.

 *
 * This implementation does not use fictitious positions at the
 * beginning or end of the Sequence, and the head and tail node have
 * null pointers past the beginning or end of the Sequence.

 *
 * The non-interface methods for inserting positions are implemented
 * separately in order to allow greater constant-factor efficiency
 * and comprehensibility in
 * the Sequence insertion methods and to allow later separation of their
 * functionality.
 * @author Benoit Hudson
 * @author Mark Handy
 * @author Andrew Schwerin
 * @author Ryan Shaun Baker
 * @version JDSL 2.1.1
 */
public class NodeSequence extends AbstractPositionalContainer
  implements Sequence {

  /**
    * The stored size of the Sequence -- modified on insertion or removal.
    */
    private int size_;

  /**
    * The first and last nodes of the Sequence
    */
    private FNSNode tail_, head_;

  /**
    * Cache for positions and elements; discarded upon modification
    */
    private Position positions_[] = null;
    private Object elements_[] = null;

  /**
    * The default constructor for NodeSequence, as well as the only one.
    */
    public NodeSequence() {
        super();
    }
    public Container newContainer() {
        return new NodeSequence();
    }

  /**
    * O(1) time
    */
    public Position first() throws EmptyContainerException {
        checkEmpty();
        return head_;
    }

  /**
    * O(1) time
    */
    public Position last() throws EmptyContainerException {
        checkEmpty();
        return tail_;
    }

  /**
    * O(1) time
    */
    public boolean isFirst (Position p) throws InvalidAccessorException {
        castPosition (p);
        return (p==head_);
    }

  /**
    * O(1) time
    */
    public boolean isLast (Position p) throws InvalidAccessorException  {
        castPosition (p);
        return (p==tail_);
    }

  /**
    * O(1) time if the positions_ cache is valid (no modifications since
    * cache was generated)
    * O(N) if cache is invalid (must traverse up to half of Sequence)
    */
    public Position atRank (int rank) throws BoundaryViolationException {
        checkRank (rank);

        // if the positions_ cache is valid, we can return in O(1) time
        if(positions_!=null) {
            return positions_[rank];
        }

        // otherwise, iterate through the list
        else {
	  //we save half of N by going from the appropriate end
	  if (rank<=size()/2){
            FNSNode cur = head_;
            for(int i=0; i<rank; i++)  {
                cur = cur.next();
            }
            return cur;
	  }
	  else{
            FNSNode cur = tail_;
            for(int i=size()-1; i>rank; i--)  {
                cur = cur.prev();
            }
            return cur;
	  }

        }
    }

  /**
    * O(1) time if the positions_ cache is valid (no modifications since
    * cache was generated)
    * O(N) if cache is invalid (must traverse rank elements of Sequence)
    */
    public int rankOf (Position p) throws InvalidAccessorException {
        FNSNode n = castPosition(p);

        // if the positions_ cache is valid, we can iterate through an array
        if(positions_!=null) {
            for(int i=0; i<positions_.length; i++) {
                if(positions_[i]==p) return i;
            }
            // to placate the compiler:
            throw new RuntimeException
                ("Internal error: "+p+" is valid but not found");
        } else {
            // otherwise, iterate through the list (backwards)
            int rank=0;
            while(n!=head_) { rank++; n = n.prev(); }
            return rank;
        }
    }

  /**
    * O(1) time
    */
    public Position before (Position p) throws InvalidAccessorException {
      FNSNode n = castPosition(p);
      if(n==head_)
	throw new BoundaryViolationException("At first element");
      return n.prev();
    }

  /**
    * O(1) time
    */
    public Position after (Position p) throws InvalidAccessorException {
      FNSNode n = castPosition(p);
      if(n==tail_)
	throw new BoundaryViolationException("At last element");
      return n.next();
    }

  /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Position insertBefore (Position p, Object elt)
                                  throws InvalidAccessorException  {
	Position nu = new FNSNode(elt);
	posInsertBefore(p, nu);
        return nu;
    }

  /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Position insertFirst(Object elt) throws InvalidAccessorException {
  	Position nu = new FNSNode(elt);
	if (isEmpty())
	  posInsertOnly(nu);
	else
	  posInsertBefore(head_, nu);
        return nu;
    }

  /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Position insertAfter (Position p, Object elt)
        throws InvalidAccessorException {
	  Position nu = new FNSNode(elt);
	  posInsertAfter(p, nu);
	  return nu;
    }

  /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Position insertLast(Object elt)
        throws InvalidAccessorException {
	  Position nu = new FNSNode(elt);
	  if (isEmpty())
	    posInsertOnly(nu);
	  else
	    posInsertAfter(tail_, nu);
	  return nu;
        }

   /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Position insertAtRank (int rank, Object elt)
           throws InvalidAccessorException, BoundaryViolationException  {
        if (rank == 0)      { return insertFirst(elt); }
        if (rank == size()) { return insertLast (elt); }
        checkRank (rank);
        return insertAfter(atRank(rank-1),elt);
    }

  /**
    * This method inserts a position into an empty Sequence.
    * It also clears the position cache
    * @param toInsert The Position to Insert
    * O(1) time
    */
  private void posInsertOnly(Position toInsert)
                              throws InvalidAccessorException{
    try{
      FNSNode toins = (FNSNode)toInsert;
      head_ = toins;
      tail_ = toins;
      size_ = 1;
      toins.setContainer(this);
      toins.setPrev(null);
      toins.setNext(null);
      positions_ = null;
      elements_ = null;
    }
    catch(ClassCastException cce){
      throw new InvalidAccessorException
	("Wrong class " + toInsert.getClass() );
    }
  }

   /**
 * Make toInsert the first position of this sequence
 * @param toInsert Position of a compatible type for this sequence
 * @exception InvalidAccessorException If toInsert is already
 * contained or is of an incompatible type
    * This method also clears the position cache.
    * O(1) time
    */
  public void posInsertFirst( Position toInsert )
                              throws InvalidAccessorException {
    if (isEmpty())
      posInsertOnly(toInsert);
    else
      posInsertBefore(head_, toInsert);
  }

  /**
 * Make toInsert the last position of this sequence
 * @param toInsert Position of a compatible type for this sequence
 * @exception InvalidAccessorException If toInsert is already
 * contained or is of an incompatible type
    * This method also clears the position cache.
    * O(1) time
    */
  public void posInsertLast( Position toInsert )
                             throws InvalidAccessorException {
    if (isEmpty())
      posInsertOnly(toInsert);
    else
      posInsertAfter(tail_, toInsert);
  }

  /**
 * Make toInsert the predecessor of willBeSuccessor
 * @param willBeSuccessor a position in this sequence
 * @param toInsert Position of a compatible type for this sequence
 * @exception InvalidAccessorException If toInsert is already
 * contained or is of an incompatible type, or if willBeSuccessor
 * is invalid for one of the usual invalid-position reasons
    * This method also clears the position cache.
    * O(1) time
    */
  public void posInsertBefore( Position willBeSuccessor, Position toInsert )
                               throws InvalidAccessorException {

    if (contains(toInsert))
      throw new InvalidAccessorException
	("This container already contains that position.");

    // clear the caches
    positions_= null;
    elements_= null;

    FNSNode fwillbesucc = castPosition(willBeSuccessor);
    FNSNode ftoInsert = null;

    //we can't use castPosition because it SHOULD BE uncontained
    try{
      ftoInsert = (FNSNode)toInsert;
    }
    catch(ClassCastException cce){
      throw new InvalidAccessorException
	("Node to insert is of the wrong class.");
    }

    if(fwillbesucc==head_) { //We're de-facto inserting first
      ftoInsert.setPrev(null);
      ftoInsert.setNext(fwillbesucc);
      ftoInsert.setContainer(this);

      fwillbesucc.setPrev(ftoInsert);

      head_ = ftoInsert;
      if(tail_ == null)
	tail_ = head_;
    } else {//inserting somewhere in the middle
      ftoInsert.setPrev(fwillbesucc.prev());
      fwillbesucc.prev().setNext(ftoInsert);
      ftoInsert.setNext(fwillbesucc);
      fwillbesucc.setPrev(ftoInsert);
      ftoInsert.setContainer(this);
    }
    size_++;
  }

  /**
 * Make toInsert the successor of willBePredecessor
 * @param willBePredecessor a position in this sequence
 * @param toInsert Position of a compatible type for this sequence
 * @exception InvalidAccessorException If toInsert is already
 * contained or is of an incompatible type, or if willBePredecessor
 * is invalid for one of the usual invalid-position reasons
    * This method also clears the position cache.
    * O(1) time
    */
  public void posInsertAfter( Position willBePredecessor, Position toInsert )
                              throws InvalidAccessorException {
    if (contains(toInsert))
      throw new InvalidAccessorException
	("This container already contains that position.");

    // clear the caches
    positions_= null;
    elements_= null;

    FNSNode fwillbepred = castPosition(willBePredecessor);
    FNSNode ftoInsert=null;

    //we can't use castPosition because it SHOULD BE uncontained
    try{
      ftoInsert = (FNSNode)toInsert;
    }
    catch(ClassCastException cce){
      throw new InvalidAccessorException
	("Node to insert is of the wrong class.");
    }

    if(fwillbepred==tail_) { //We're de-facto inserting last
      ftoInsert.setNext(null);
      ftoInsert.setPrev(fwillbepred);
      ftoInsert.setContainer(this);

      fwillbepred.setNext(ftoInsert);

      tail_ = ftoInsert;
      if(head_ == null)
	head_ = tail_;
    } else {//inserting somewhere in the middle
      ftoInsert.setNext(fwillbepred.next());
      fwillbepred.next().setPrev(ftoInsert);
      ftoInsert.setPrev(fwillbepred);
      fwillbepred.setNext(ftoInsert);
      ftoInsert.setContainer(this);
    }
    size_++;
  }

  /**
 * Make toInsert the rank'th position in this sequence
 * @param rank for n the size of this sequence, rank must be in [0,n]
 * @param toInsert Position of a compatible type for this sequence
 * @exception InvalidAccessorException If toInsert is already
 * contained or is of an incompatible type
    * This method also clears the position cache.
    * O(1) time
    */
  public void posInsertAtRank( int rank, Position toInsert )
                               throws InvalidAccessorException {
    if (contains(toInsert))
      throw new InvalidAccessorException
	("This container already contains that position.");

    if (rank == 0)      { posInsertFirst(toInsert);return;}
    if (rank == size()) { posInsertLast (toInsert);return; }
    checkRank (rank);
    FNSNode n = (FNSNode)atRank(rank-1);
    posInsertAfter(n,toInsert);
  }

  /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Object remove (Position p) throws InvalidAccessorException {
        FNSNode n = castPosition(p);
          FNSNode prev = n.prev();
        FNSNode next = n.next();

        // clear the cache
        positions_ = null;
	elements_ = null;

        Object retval = n.element();
        n.setContainer(null);

        // skip over the position we're removing.
        if(prev!=null) {
            prev.setNext(next);
        } else {
            head_ = next;
        }
        if(next!=null) {
            next.setPrev(prev);
        } else {
            tail_ = prev;
        }

        size_--;
        return retval;
    }

  /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Object removeAfter(Position p) throws InvalidAccessorException {
        return remove(after(p));
    }

  /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Object removeBefore(Position p) throws InvalidAccessorException {
        return remove(before(p));
    }

  /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Object removeFirst() throws InvalidAccessorException {
        return remove(first());
    }

  /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Object removeLast() throws InvalidAccessorException {
        return remove(last());
    }

  /**
    * This method also clears the position cache.
    * O(1) time
    */
    public Object removeAtRank(int i) throws InvalidAccessorException {
        return remove(atRank(i));
    }

  /**
    * O(1) time
    */
    public int size() {
        return size_;
    }

  /**
    * O(1) time
    */
  public Object replaceElement(Accessor a, Object newElement)
                               throws InvalidAccessorException {

    //clear the elements but not the positions cache
    elements_ = null;
    FNSNode afns = castPosition(a);
    Object retval = afns.element();
    afns.setElement(newElement);
    return retval;
  }

  /**
    * O(1) time if the cache already exists
    * Otherwise O(N) to construct it
    */
  public PositionIterator positions(){
        // if the cache is invalid, create it
        if(positions_ == null) {
            positions_ = new Position[size_];
            FNSNode cur = head_;
            for(int i=0; i<size_; i++) {
                positions_[i] = cur;
                cur = cur.next();
            }
        }
        return new ArrayPositionIterator(positions_);
  }

  /**
    * O(1) time if the cache already exists
    * Otherwise O(N) to construct it
    */
  public ObjectIterator elements(){
        // if the cache is invalid, create it
        if(elements_ == null) {
            elements_ = new Object[size_];
            FNSNode cur = head_;
            for(int i=0; i<size_; i++) {
                elements_[i] = cur.element();
                cur = cur.next();
            }
        }
        return new ArrayObjectIterator(elements_);
  }

  /**
    * O(1) time
    */
  public boolean contains(Accessor a) throws InvalidAccessorException {
    if (a == null)
      throw new InvalidAccessorException
	("A null position cannot be contained.");
    else if (a instanceof FNSNode)
      return ((FNSNode)a).container() == this;
    else
      return false;
  }

  public String toString(){
    return ToString.stringfor(this);
  }

    // Convenience methods

  /**
    * This method throws an exception if the Sequence is empty.
    * O(1) time
    */
    private final void checkEmpty()
        throws EmptyContainerException {
            if(isEmpty()) throw new EmptyContainerException
			    ("Sequence is empty");
        }

  /**
    * This method throws an exception if the rank is out of bounds
    * @param rank The rank to check
    * O(1) time
    */
    private final void checkRank(int rank)
        throws BoundaryViolationException {
            if (rank < 0 || rank >= size_) throw new BoundaryViolationException
                ("Rank " +rank+ " out of range [0.."+size_+")");
        }

  /**
    * This method throws an exception if the position is
    * not a non-null FNSNode contained by this.
    * @param a The accessor to check
    * O(1) time
    */
  private final FNSNode castPosition(Accessor a)
    throws InvalidAccessorException {

    if (a==null)
      throw new InvalidAccessorException("null accessor");

    FNSNode n;
    try{
      n = (FNSNode)a;
    }
    catch (ClassCastException cce) {
      throw new InvalidAccessorException("Wrong class " + a.getClass() );
    }

    if (n.container() != this)
      throw new InvalidAccessorException("wrong container");

    return n;
  }

    // ------------------------------------------------------

    /**
     * This nested class is the node for NodeSequence.
     * It is Decorable, and a position.  It is public per request of mdh,
     * who hacked with it in the low-overhead implementation of
     * Graph.
     */

    public static class FNSNode extends HashtableDecorable
    implements Position {

	/**
	 * The nodes immediately before and after this one (may be null
	 * if this node is at an end of the Sequence)
	 * @serial
	 */
        private FNSNode next_, prev_;

	/**
	 * The container that this node belongs to
	 * (this makes O(1) time calls to contains() possible)
	 * @serial
	 */
        private InspectableContainer cont_;

	/**
	 * The element this position stores
	 * @serial
	 */
        private Object  elt_;

	/**
	 * Constructor for the Node.
	 * @param prev The node before this one in the Sequence. (may be null)
	 * @param next The node after this one in the Sequence. (may be null)
	 * @param cont The node's container. (may be null)
	 * @param elt The node's element. (null if the element is really null)
	 */
        private FNSNode(FNSNode prev, FNSNode next,
		InspectableContainer cont, Object elt) {
            prev_ = prev; if(prev!=null) prev.setNext(this);
            next_ = next; if(next!=null) next.setPrev(this);
            cont_ = cont;
            elt_ = elt;
        }

      /**
	 * Default constructor for the Node.
	 * @param elt The node's element. (null if the element is really null)
	 */
      public FNSNode(Object elt){
	prev_ = null;
	next_ = null;
	cont_ = null;
	elt_ = elt;
      }

        public final Object element() {
            return elt_;
        }

	/**
	 * Gets the node after this one in the Sequence
	 * @return The node after this one in the Sequence
	 */
        final FNSNode next() { return next_; }

	/**
	 * Gets the node before this one in the Sequence
	 * @return The node before this one in the Sequence
	 */
        final FNSNode prev() { return prev_; }

	/**
	 * Sets the node after this one in the Sequence
	 * @param n The node after this one in the Sequence
	 */
        private final void setNext(FNSNode n) { next_ = n; }

	/**
	 * Sets the node before this one in the Sequence
	 * @param p The node before this one in the Sequence
	 */
        private final void setPrev(FNSNode p) { prev_ = p; }

	/**
	 * Sets the position's element
	 * @param elt The position's new element
	 */
	protected final void setElement(Object elt) {
            elt_ = elt;
        }

	/**
	 * Gets the position's container, for O(1) time implementation of contains()
	 * @return The position's container
	 */
	final InspectableContainer container() {
	    return cont_;
	}

	/**
	 * Sets the position's container, for O(1) time implementation of contains()
	 * @param c The position's container
	 */
	final void setContainer(InspectableContainer c){
	    cont_ = c;
	}

	public String toString(){
	    return ToString.stringfor(this);
	}
    }

}


text:
package ${package}.boot;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.FilterType;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RestController;

@Configuration
@ComponentScan(value = { "org.shijie99.basic" },
	excludeFilters =
	{
		@ComponentScan.Filter(type = FilterType.ANNOTATION,
			value = {
				Controller.class,
				RestController.class
			}
		)
	}
)
public class SpringConfig {

}


text:
// Tests that the developer toolbar errors count works properly.

function test() {
  const TEST_URI = "http://example.com/browser/browser/devtools/shared/test/browser_toolbar_webconsole_errors_count.html";

  let imported = {};
  Components.utils.import("resource:///modules/HUDService.jsm", imported);
  let HUDService = imported.HUDService;

  let webconsole = document.getElementById("developer-toolbar-webconsole");
  let toolbar = document.getElementById("Tools:DevToolbar");
  let tab1, tab2;

  function openToolbar(browser, tab) {
    tab1 = tab;
    ignoreAllUncaughtExceptions(false);

    ok(!DeveloperToolbar.visible, "DeveloperToolbar is not visible");

    expectUncaughtException();
    oneTimeObserve(DeveloperToolbar.NOTIFICATIONS.SHOW, onOpenToolbar);
    toolbar.doCommand();
  }

  ignoreAllUncaughtExceptions();
  addTab(TEST_URI, openToolbar);

  function getErrorsCount() {
    let count = webconsole.getAttribute("error-count");
    return count ? count : "0";
  }

  function onOpenToolbar() {
    ok(DeveloperToolbar.visible, "DeveloperToolbar is visible");

    waitForValue({
      name: "web console button shows page errors",
      validator: getErrorsCount,
      value: 3,
      success: addErrors,
      failure: finish,
    });
  }

  function addErrors() {
    expectUncaughtException();

    waitForFocus(function() {
      let button = content.document.querySelector("button");
      EventUtils.synthesizeMouse(button, 2, 2, {}, content);
    }, content);

    waitForValue({
      name: "button shows one more error after click in page",
      validator: getErrorsCount,
      value: 4,
      success: function() {
        ignoreAllUncaughtExceptions();
        addTab(TEST_URI, onOpenSecondTab);
      },
      failure: finish,
    });
  }

  function onOpenSecondTab(browser, tab) {
    tab2 = tab;

    ignoreAllUncaughtExceptions(false);
    expectUncaughtException();

    waitForValue({
      name: "button shows correct number of errors after new tab is open",
      validator: getErrorsCount,
      value: 3,
      success: switchToTab1,
      failure: finish,
    });
  }

  function switchToTab1() {
    gBrowser.selectedTab = tab1;
    waitForValue({
      name: "button shows the page errors from tab 1",
      validator: getErrorsCount,
      value: 4,
      success: function() {
        openWebConsole(tab1, onWebConsoleOpen);
      },
      failure: finish,
    });
  }

  function openWebConsole(tab, callback)
  {
    function _onWebConsoleOpen(subject)
    {
      subject.QueryInterface(Ci.nsISupportsString);
      let hud = HUDService.getHudReferenceById(subject.data);
      executeSoon(callback.bind(null, hud));
    }

    oneTimeObserve("web-console-created", _onWebConsoleOpen);

    HUDService.activateHUDForContext(tab);
  }

  function onWebConsoleOpen(hud) {
    waitForValue({
      name: "web console shows the page errors",
      validator: function() {
        return hud.outputNode.querySelectorAll(".hud-exception").length;
      },
      value: 4,
      success: checkConsoleOutput.bind(null, hud),
      failure: finish,
    });
  }

  function checkConsoleOutput(hud) {
    let errors = ["foobarBug762996a", "foobarBug762996b", "foobarBug762996load",
                  "foobarBug762996click", "foobarBug762996consoleLog",
                  "foobarBug762996css"];
    errors.forEach(function(error) {
      isnot(hud.outputNode.textContent.indexOf(error), -1,
            error + " found in the Web Console output");
    });

    hud.jsterm.clearOutput();

    is(hud.outputNode.textContent.indexOf("foobarBug762996color"), -1,
       "clearOutput() worked");

    expectUncaughtException();
    let button = content.document.querySelector("button");
    EventUtils.synthesizeMouse(button, 2, 2, {}, content);

    waitForValue({
      name: "button shows one more error after another click in page",
      validator: getErrorsCount,
      value: 5,
      success: function() {
        waitForValue(waitForNewError);
      },
      failure: finish,
    });

    let waitForNewError = {
      name: "the Web Console displays the new error",
      validator: function() {
        return hud.outputNode.textContent.indexOf("foobarBug762996click") > -1;
      },
      success: doClearConsoleButton.bind(null, hud),
      failure: finish,
    };
  }

  function doClearConsoleButton(hud) {
    let clearButton = hud.ui.rootElement
                      .querySelector(".webconsole-clear-console-button");
    EventUtils.synthesizeMouse(clearButton, 2, 2, {}, hud.iframeWindow);

    is(hud.outputNode.textContent.indexOf("foobarBug762996click"), -1,
       "clear console button worked");
    is(getErrorsCount(), 0, "page errors counter has been reset");

    doPageReload(hud);
  }

  function doPageReload(hud) {
    tab1.linkedBrowser.addEventListener("load", function _onReload() {
      tab1.linkedBrowser.removeEventListener("load", _onReload, true);
      ignoreAllUncaughtExceptions(false);
      expectUncaughtException();
    }, true);

    ignoreAllUncaughtExceptions();
    content.location.reload();

    waitForValue({
      name: "the Web Console button count has been reset after page reload",
      validator: getErrorsCount,
      value: 3,
      success: function() {
        waitForValue(waitForConsoleOutputAfterReload);
      },
      failure: finish,
    });

    let waitForConsoleOutputAfterReload = {
      name: "the Web Console displays the correct number of errors after reload",
      validator: function() {
        return hud.outputNode.querySelectorAll(".hud-exception").length;
      },
      value: 3,
      success: function() {
        isnot(hud.outputNode.textContent.indexOf("foobarBug762996load"), -1,
              "foobarBug762996load found in console output after page reload");
        testEnd();
      },
      failure: testEnd,
    };
  }

  function testEnd() {
    document.getElementById("developer-toolbar-closebutton").doCommand();
    HUDService.deactivateHUDForContext(tab1);
    gBrowser.removeTab(tab1);
    gBrowser.removeTab(tab2);
    finish();
  }

  function oneTimeObserve(name, callback) {
    function _onObserve(aSubject, aTopic, aData) {
      Services.obs.removeObserver(_onObserve, name);
      callback(aSubject, aTopic, aData);
    };
    Services.obs.addObserver(_onObserve, name, false);
  }
}


text:
import datetime
import os
import pickle
import subprocess
import sys

from django.core.files.temp import NamedTemporaryFile
from django.db import DJANGO_VERSION_PICKLE_KEY, models
from django.test import TestCase, mock
from django.utils._os import npath, upath
from django.utils.version import get_version

from .models import Article

class ModelPickleTestCase(TestCase):
    def test_missing_django_version_unpickling(self):
        """
        #21430 -- Verifies a warning is raised for models that are
        unpickled without a Django version
        """
        class MissingDjangoVersion(models.Model):
            title = models.CharField(max_length=10)

            def __reduce__(self):
                reduce_list = super(MissingDjangoVersion, self).__reduce__()
                data = reduce_list[-1]
                del data[DJANGO_VERSION_PICKLE_KEY]
                return reduce_list

        p = MissingDjangoVersion(title="FooBar")
        msg = "Pickled model instance's Django version is not specified."
        with self.assertRaisesMessage(RuntimeWarning, msg):
            pickle.loads(pickle.dumps(p))

    def test_unsupported_unpickle(self):
        """
        #21430 -- Verifies a warning is raised for models that are
        unpickled with a different Django version than the current
        """
        class DifferentDjangoVersion(models.Model):
            title = models.CharField(max_length=10)

            def __reduce__(self):
                reduce_list = super(DifferentDjangoVersion, self).__reduce__()
                data = reduce_list[-1]
                data[DJANGO_VERSION_PICKLE_KEY] = '1.0'
                return reduce_list

        p = DifferentDjangoVersion(title="FooBar")
        msg = "Pickled model instance's Django version 1.0 does not match the current version %s." % get_version()
        with self.assertRaisesMessage(RuntimeWarning, msg):
            pickle.loads(pickle.dumps(p))

    def test_unpickling_when_appregistrynotready(self):
        """
        #24007 -- Verifies that a pickled model can be unpickled without having
        to manually setup the apps registry beforehand.
        """
        script_template = """#!/usr/bin/env python
import pickle

from django.conf import settings

data = %r

settings.configure(DEBUG=False, INSTALLED_APPS=('model_regress',), SECRET_KEY = "blah")
article = pickle.loads(data)
print(article.headline)"""
        a = Article.objects.create(
            headline="Some object",
            pub_date=datetime.datetime.now(),
            article_text="This is an article",
        )

        with NamedTemporaryFile(mode='w+', suffix=".py") as script:
            script.write(script_template % pickle.dumps(a))
            script.flush()
            # A path to model_regress must be set in PYTHONPATH
            model_regress_dir = os.path.dirname(upath(__file__))
            model_regress_path = os.path.abspath(model_regress_dir)
            tests_path = os.path.split(model_regress_path)[0]
            pythonpath = os.environ.get('PYTHONPATH', '')
            pythonpath = npath(os.pathsep.join([tests_path, pythonpath]))

            with mock.patch.dict('os.environ', {'PYTHONPATH': pythonpath}):
                try:
                    result = subprocess.check_output([sys.executable, script.name])
                except subprocess.CalledProcessError:
                    self.fail("Unable to reload model pickled data")
        self.assertEqual(result.strip().decode(), "Some object")


text:
describe('choose-card', () => {
  it.skip('Should choose more unscored cards at low p(learned)', async () => {
    expect(true).toBe(false)
  })

  it.skip('Should choose more scored cards at high p(learned)', async () => {
    expect(true).toBe(false)
  })

  it.skip('Only choose cards in the subject', async () => {
    expect(true).toBe(false)
  })

  it.skip('Should not choose the previous card', async () => {
    expect(true).toBe(false)
  })

  it.skip('Requires a subject_id', async () => {
    expect(true).toBe(false)
  })
})


text:
package org.opensirf.jaxrs.storage;

/**
 * @author pviana
 *
 */
public class StorageContainerNotFoundException extends RuntimeException {

	/**
	 * @param string
	 */
	public StorageContainerNotFoundException(String string) {
		super(string);
	}

	private static final long serialVersionUID = 1L;

}