text:
package com.intellij.openapi.vfs.impl;

import com.intellij.openapi.Disposable;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.components.ApplicationComponent;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.util.*;
import com.intellij.openapi.util.io.FileUtil;
import com.intellij.openapi.util.text.StringUtil;
import com.intellij.openapi.vfs.*;
import com.intellij.openapi.vfs.ex.temp.TempFileSystem;
import com.intellij.openapi.vfs.newvfs.BulkFileListener;
import com.intellij.openapi.vfs.newvfs.events.*;
import com.intellij.openapi.vfs.pointers.VirtualFilePointer;
import com.intellij.openapi.vfs.pointers.VirtualFilePointerContainer;
import com.intellij.openapi.vfs.pointers.VirtualFilePointerListener;
import com.intellij.openapi.vfs.pointers.VirtualFilePointerManager;
import com.intellij.util.ConcurrencyUtil;
import com.intellij.util.SmartList;
import com.intellij.util.containers.ContainerUtil;
import com.intellij.util.io.URLUtil;
import com.intellij.util.messages.MessageBus;
import gnu.trove.THashMap;
import gnu.trove.TObjectIntHashMap;
import gnu.trove.TObjectIntProcedure;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.jetbrains.annotations.TestOnly;

import java.util.*;
import java.util.concurrent.ConcurrentMap;

public class VirtualFilePointerManagerImpl extends VirtualFilePointerManager implements ApplicationComponent, ModificationTracker, BulkFileListener {
  private static final Logger LOG = Logger.getInstance("#com.intellij.openapi.vfs.impl.VirtualFilePointerManagerImpl");
  private final TempFileSystem TEMP_FILE_SYSTEM;
  private final LocalFileSystem LOCAL_FILE_SYSTEM;
  private final JarFileSystem JAR_FILE_SYSTEM;
  // guarded by this
  private final Map<VirtualFilePointerListener, FilePointerPartNode> myPointers = new LinkedHashMap<VirtualFilePointerListener, FilePointerPartNode>();

  // compare by identity because VirtualFilePointerContainer has too smart equals
  // guarded by myContainers
  private final Set<VirtualFilePointerContainerImpl> myContainers = ContainerUtil.newIdentityTroveSet();
  @NotNull private final VirtualFileManager myVirtualFileManager;
  @NotNull private final MessageBus myBus;
  private static final Comparator<String> URL_COMPARATOR = SystemInfo.isFileSystemCaseSensitive ? new Comparator<String>() {
    @Override
    public int compare(@NotNull String url1, @NotNull String url2) {
      return url1.compareTo(url2);
    }
  } : new Comparator<String>() {
    @Override
    public int compare(@NotNull String url1, @NotNull String url2) {
      return url1.compareToIgnoreCase(url2);
    }
  };

  VirtualFilePointerManagerImpl(@NotNull VirtualFileManager virtualFileManager,
                                @NotNull MessageBus bus,
                                @NotNull TempFileSystem tempFileSystem,
                                @NotNull LocalFileSystem localFileSystem,
                                @NotNull JarFileSystem jarFileSystem) {
    myVirtualFileManager = virtualFileManager;
    myBus = bus;
    bus.connect().subscribe(VirtualFileManager.VFS_CHANGES, this);
    TEMP_FILE_SYSTEM = tempFileSystem;
    LOCAL_FILE_SYSTEM = localFileSystem;
    JAR_FILE_SYSTEM = jarFileSystem;
  }

  @Override
  public void initComponent() {
  }

  @Override
  public void disposeComponent() {
    assertAllPointersDisposed();
  }

  @NotNull
  @Override
  public String getComponentName() {
    return "VirtualFilePointerManager";
  }

  private static class EventDescriptor {
    @NotNull private final VirtualFilePointerListener myListener;
    @NotNull private final VirtualFilePointer[] myPointers;

    private EventDescriptor(@NotNull VirtualFilePointerListener listener, @NotNull VirtualFilePointer[] pointers) {
      myListener = listener;
      myPointers = pointers;
    }

    private void fireBefore() {
      if (myPointers.length != 0) {
        myListener.beforeValidityChanged(myPointers);
      }
    }

    private void fireAfter() {
      if (myPointers.length != 0) {
        myListener.validityChanged(myPointers);
      }
    }
  }

  @NotNull
  private static VirtualFilePointer[] toPointers(@NotNull List<FilePointerPartNode> nodes) {
    if (nodes.isEmpty()) return VirtualFilePointer.EMPTY_ARRAY;
    List<VirtualFilePointer> list = new ArrayList<VirtualFilePointer>(nodes.size());
    for (FilePointerPartNode node : nodes) {
      node.addAllPointersTo(list);
    }
    return list.toArray(new VirtualFilePointer[list.size()]);
  }

  @TestOnly
  VirtualFilePointer[] getPointersUnder(VirtualFile parent, String childName) {
    List<FilePointerPartNode> nodes = new ArrayList<FilePointerPartNode>();
    addPointersUnder(parent, true, childName, nodes);
    return toPointers(nodes);
  }

  private void addPointersUnder(VirtualFile parent,
                                boolean separator,
                                @NotNull CharSequence childName,
                                @NotNull List<FilePointerPartNode> out) {
    for (FilePointerPartNode root : myPointers.values()) {
      root.addPointersUnder(parent, separator, childName, out);
    }
  }

  @Override
  @NotNull
  public synchronized VirtualFilePointer create(@NotNull String url, @NotNull Disposable parent, @Nullable VirtualFilePointerListener listener) {
    return create(null, url, parent, listener);
  }

  @Override
  @NotNull
  public synchronized VirtualFilePointer create(@NotNull VirtualFile file, @NotNull Disposable parent, @Nullable VirtualFilePointerListener listener) {
    return create(file, null, parent, listener);
  }

  @NotNull
  private VirtualFilePointer create(@Nullable("null means the pointer will be created from the (not null) url") VirtualFile file,
                                    @Nullable("null means url has to be computed from the (not-null) file path") String url,
                                    @NotNull Disposable parentDisposable,
                                    @Nullable VirtualFilePointerListener listener) {
    VirtualFileSystem fileSystem;
    String protocol;
    String path;
    if (file == null) {
      int protocolEnd = url.indexOf(URLUtil.SCHEME_SEPARATOR);
      if (protocolEnd == -1) {
        protocol = null;
        fileSystem = null;
        path = url;
      }
      else {
        protocol = url.substring(0, protocolEnd);
        fileSystem = myVirtualFileManager.getFileSystem(protocol);
        path = url.substring(protocolEnd + URLUtil.SCHEME_SEPARATOR.length());
      }
    }
    else {
      fileSystem = file.getFileSystem();
      protocol = fileSystem.getProtocol();
      path = file.getPath();
      url = VirtualFileManager.constructUrl(protocol, path);
    }

    if (fileSystem == TEMP_FILE_SYSTEM) {
      // for tests, recreate always
      VirtualFile found = file == null ? VirtualFileManager.getInstance().findFileByUrl(url) : file;
      return new IdentityVirtualFilePointer(found, url);
    }

    boolean isJar = fileSystem == JAR_FILE_SYSTEM;
    if (fileSystem != LOCAL_FILE_SYSTEM && !isJar) {
      // we are unable to track alien file systems for now
      VirtualFile found = fileSystem == null ? null : file != null ? file : VirtualFileManager.getInstance().findFileByUrl(url);
      // if file is null, this pointer will never be alive
      return getOrCreateIdentity(url, found);
    }

    if (file == null) {
      String cleanPath = cleanupPath(path, isJar);
      // if newly created path is the same as substringed from url one then the url did not change, we can reuse it
      //noinspection StringEquality
      if (cleanPath != path) {
        url = VirtualFileManager.constructUrl(protocol, cleanPath);
        path = cleanPath;
      }
    }
    // else url has come from VirtualFile.getPath() and is good enough

    VirtualFilePointerImpl pointer = getOrCreate(parentDisposable, listener, path, Pair.create(file, url));
    DelegatingDisposable.registerDisposable(parentDisposable, pointer);
    return pointer;
  }

  private final Map<String, IdentityVirtualFilePointer> myUrlToIdentity = new THashMap<String, IdentityVirtualFilePointer>();
  @NotNull
  private IdentityVirtualFilePointer getOrCreateIdentity(@NotNull String url, @Nullable VirtualFile found) {
    IdentityVirtualFilePointer pointer = myUrlToIdentity.get(url);
    if (pointer == null) {
      pointer = new IdentityVirtualFilePointer(found, url);
      myUrlToIdentity.put(url, pointer);
    }
    return pointer;
  }

  @NotNull
  private static String cleanupPath(@NotNull String path, boolean isJar) {
    path = FileUtil.normalize(path);
    path = trimTrailingSeparators(path, isJar);
    return path;
  }

  private static String trimTrailingSeparators(@NotNull String path, boolean isJar) {
    while (StringUtil.endsWithChar(path, '/') && !(isJar && path.endsWith(JarFileSystem.JAR_SEPARATOR))) {
      path = StringUtil.trimEnd(path, "/");
    }
    return path;
  }

  @NotNull
  private VirtualFilePointerImpl getOrCreate(@NotNull Disposable parentDisposable,
                                             @Nullable VirtualFilePointerListener listener,
                                             @NotNull String path,
                                             @NotNull Pair<VirtualFile, String> fileAndUrl) {
    FilePointerPartNode root = myPointers.get(listener);
    FilePointerPartNode node;
    if (root == null) {
      root = new FilePointerPartNode(path, null, fileAndUrl);
      root.pointersUnder++;
      myPointers.put(listener, root);
      node = root;
    }
    else {
      node = root.findPointerOrCreate(path, 0, fileAndUrl, 1);
    }

    VirtualFilePointerImpl pointer = node.getAnyPointer();
    if (pointer == null) {
      pointer = new VirtualFilePointerImpl(listener, parentDisposable, fileAndUrl);
      node.associate(pointer, fileAndUrl);
    }
    pointer.myNode.incrementUsageCount(1);

    root.checkConsistency();
    return pointer;
  }

  @Override
  @NotNull
  public synchronized VirtualFilePointer duplicate(@NotNull VirtualFilePointer pointer,
                                                   @NotNull Disposable parent,
                                                   @Nullable VirtualFilePointerListener listener) {
    VirtualFile file = pointer.getFile();
    return file == null ? create(pointer.getUrl(), parent, listener) : create(file, parent, listener);
  }

  private synchronized void assertAllPointersDisposed() {
    for (Map.Entry<VirtualFilePointerListener, FilePointerPartNode> entry : myPointers.entrySet()) {
      FilePointerPartNode root = entry.getValue();
      List<FilePointerPartNode> left = new ArrayList<FilePointerPartNode>();
      List<VirtualFilePointerImpl> pointers = new ArrayList<VirtualFilePointerImpl>();
      root.addPointersUnder(null, false, "", left);
      for (FilePointerPartNode node : left) {
        node.addAllPointersTo(pointers);
      }
      if (!pointers.isEmpty()) {
        VirtualFilePointerImpl p = pointers.get(0);
        try {
          p.throwDisposalError("Not disposed pointer: "+p);
        }
        finally {
          for (VirtualFilePointerImpl pointer : pointers) {
            pointer.dispose();
          }
        }
      }
    }

    synchronized (myContainers) {
      if (!myContainers.isEmpty()) {
        VirtualFilePointerContainerImpl container = myContainers.iterator().next();
        container.throwDisposalError("Not disposed container");
      }
    }
  }

  private final Set<VirtualFilePointerImpl> myStoredPointers = ContainerUtil.newIdentityTroveSet();

  @TestOnly
  public void storePointers() {
    myStoredPointers.clear();
    addAllPointersTo(myStoredPointers);
  }

  @TestOnly
  public void assertPointersAreDisposed() {
    List<VirtualFilePointerImpl> pointers = new ArrayList<VirtualFilePointerImpl>();
    addAllPointersTo(pointers);
    try {
      for (VirtualFilePointerImpl pointer : pointers) {
        if (!myStoredPointers.contains(pointer)) {
          pointer.throwDisposalError("Virtual pointer hasn't been disposed: "+pointer);
        }
      }
    }
    finally {
      myStoredPointers.clear();
    }
  }

  @TestOnly
  private void addAllPointersTo(@NotNull Collection<VirtualFilePointerImpl> pointers) {
    List<FilePointerPartNode> out = new ArrayList<FilePointerPartNode>();
    for (FilePointerPartNode root : myPointers.values()) {
      root.addPointersUnder(null, false, "", out);
    }
    for (FilePointerPartNode node : out) {
      node.addAllPointersTo(pointers);
    }
  }

  @Override
  public void dispose() {
  }

  @Override
  @NotNull
  public VirtualFilePointerContainer createContainer(@NotNull Disposable parent) {
    return createContainer(parent, null);
  }

  @Override
  @NotNull
  public synchronized VirtualFilePointerContainer createContainer(@NotNull Disposable parent, @Nullable VirtualFilePointerListener listener) {
    return registerContainer(parent, new VirtualFilePointerContainerImpl(this, parent, listener));
  }

  @NotNull
  private VirtualFilePointerContainer registerContainer(@NotNull Disposable parent, @NotNull final VirtualFilePointerContainerImpl virtualFilePointerContainer) {
    synchronized (myContainers) {
      myContainers.add(virtualFilePointerContainer);
    }
    Disposer.register(parent, new Disposable() {
      @Override
      public void dispose() {
        Disposer.dispose(virtualFilePointerContainer);
        boolean removed;
        synchronized (myContainers) {
          removed = myContainers.remove(virtualFilePointerContainer);
        }
        if (!ApplicationManager.getApplication().isUnitTestMode()) {
          assert removed;
        }
      }

      @Override
      @NonNls
      @NotNull
      public String toString() {
        return "Disposing container " + virtualFilePointerContainer;
      }
    });
    return virtualFilePointerContainer;
  }

  private List<EventDescriptor> myEvents = Collections.emptyList();
  private List<FilePointerPartNode> myNodesToUpdateUrl = Collections.emptyList();
  private List<FilePointerPartNode> myNodesToFire = Collections.emptyList();

  @Override
  public void before(@NotNull final List<? extends VFileEvent> events) {
    List<FilePointerPartNode> toFireEvents = new ArrayList<FilePointerPartNode>();
    List<FilePointerPartNode> toUpdateUrl = new ArrayList<FilePointerPartNode>();
    VirtualFilePointer[] toFirePointers;

    synchronized (this) {
      incModificationCount();
      for (VFileEvent event : events) {
        if (event instanceof VFileDeleteEvent) {
          final VFileDeleteEvent deleteEvent = (VFileDeleteEvent)event;
          addPointersUnder(deleteEvent.getFile(), false, "", toFireEvents);

        }
        else if (event instanceof VFileCreateEvent) {
          final VFileCreateEvent createEvent = (VFileCreateEvent)event;
          addPointersUnder(createEvent.getParent(), true, createEvent.getChildName(), toFireEvents);
        }
        else if (event instanceof VFileCopyEvent) {
          final VFileCopyEvent copyEvent = (VFileCopyEvent)event;
          addPointersUnder(copyEvent.getNewParent(), true, copyEvent.getFile().getName(), toFireEvents);
        }
        else if (event instanceof VFileMoveEvent) {
          final VFileMoveEvent moveEvent = (VFileMoveEvent)event;
          VirtualFile eventFile = moveEvent.getFile();
          addPointersUnder(moveEvent.getNewParent(), true, eventFile.getName(), toFireEvents);

          List<FilePointerPartNode> nodes = new ArrayList<FilePointerPartNode>();
          addPointersUnder(eventFile, false, "", nodes);
          for (FilePointerPartNode node : nodes) {
            VirtualFilePointerImpl pointer = node.getAnyPointer();
            VirtualFile file = pointer == null ? null : pointer.getFile();
            if (file != null) {
              toUpdateUrl.add(node);
            }
          }
        }
        else if (event instanceof VFilePropertyChangeEvent) {
          final VFilePropertyChangeEvent change = (VFilePropertyChangeEvent)event;
          if (VirtualFile.PROP_NAME.equals(change.getPropertyName())) {
            VirtualFile eventFile = change.getFile();
            VirtualFile parent = eventFile.getParent(); // e.g. for LightVirtualFiles
            addPointersUnder(parent, true, change.getNewValue().toString(), toFireEvents);

            List<FilePointerPartNode> nodes = new ArrayList<FilePointerPartNode>();
            addPointersUnder(eventFile, false, "", nodes);
            for (FilePointerPartNode node : nodes) {
              VirtualFilePointerImpl pointer = node.getAnyPointer();
              VirtualFile file = pointer == null ? null : pointer.getFile();
              if (file != null) {
                toUpdateUrl.add(node);
              }
            }
          }
        }
      }

      myEvents = new ArrayList<EventDescriptor>();
      toFirePointers = toPointers(toFireEvents);
      for (final VirtualFilePointerListener listener : myPointers.keySet()) {
        if (listener == null) continue;
        List<VirtualFilePointer> filtered = ContainerUtil.filter(toFirePointers, new Condition<VirtualFilePointer>() {
          @Override
          public boolean value(VirtualFilePointer pointer) {
            return ((VirtualFilePointerImpl)pointer).getListener() == listener;
          }
        });
        if (!filtered.isEmpty()) {
          EventDescriptor event = new EventDescriptor(listener, filtered.toArray(new VirtualFilePointer[filtered.size()]));
          myEvents.add(event);
        }
      }
    }

    for (EventDescriptor descriptor : myEvents) {
      descriptor.fireBefore();
    }

    if (!toFireEvents.isEmpty()) {
      myBus.syncPublisher(VirtualFilePointerListener.TOPIC).beforeValidityChanged(toFirePointers);
    }

    myNodesToFire = toFireEvents;
    myNodesToUpdateUrl = toUpdateUrl;
  }

  @Override
  public void after(@NotNull final List<? extends VFileEvent> events) {
    incModificationCount();

    for (FilePointerPartNode node : myNodesToUpdateUrl) {
      synchronized (this) {
        String urlBefore = node.myFileAndUrl.second;
        Pair<VirtualFile,String> after = node.update();
        String urlAfter = after.second;
        if (URL_COMPARATOR.compare(urlBefore, urlAfter) != 0) {
          List<VirtualFilePointerImpl> myPointers = new SmartList<VirtualFilePointerImpl>();
          node.addAllPointersTo(myPointers);

          // url has changed, reinsert
          int useCount = node.useCount;
          FilePointerPartNode root = node.remove();
          FilePointerPartNode newNode = root.findPointerOrCreate(VfsUtilCore.urlToPath(urlAfter), 0, after, myPointers.size());
          VirtualFilePointer existingPointer = newNode.getAnyPointer();
          if (existingPointer != null) {
            // can happen when e.g. file renamed to the existing file
            // merge two pointers
            for (FilePointerPartNode n = newNode; n != null; n = n.parent) {
              n.pointersUnder += myPointers.size();
            }
          }
          newNode.addAllPointersTo(myPointers);
          VirtualFilePointerImpl[] newMyPointers = myPointers.toArray(new VirtualFilePointerImpl[myPointers.size()]);
          newNode.associate(newMyPointers, after);
          newNode.incrementUsageCount(useCount);
        }
      }
    }

    VirtualFilePointer[] pointersToFireArray = toPointers(myNodesToFire);
    for (VirtualFilePointer pointer : pointersToFireArray) {
      ((VirtualFilePointerImpl)pointer).myNode.update();
    }

    for (EventDescriptor event : myEvents) {
      event.fireAfter();
    }

    if (pointersToFireArray.length != 0) {
      myBus.syncPublisher(VirtualFilePointerListener.TOPIC).validityChanged(pointersToFireArray);
    }

    myNodesToUpdateUrl = Collections.emptyList();
    myEvents = Collections.emptyList();
    myNodesToFire = Collections.emptyList();
    for (FilePointerPartNode root : myPointers.values()) {
      root.checkConsistency();
    }
  }

  void removeNode(@NotNull FilePointerPartNode node, VirtualFilePointerListener listener) {
    FilePointerPartNode root = node.remove();
    boolean rootNodeEmpty = root.children.length == 0 ;
    if (rootNodeEmpty) {
      myPointers.remove(listener);
    }
    else {
      myPointers.get(listener).checkConsistency();
    }
  }

  private static class DelegatingDisposable implements Disposable {
    private static final ConcurrentMap<Disposable, DelegatingDisposable> ourInstances =
      ContainerUtil.newConcurrentMap(ContainerUtil.<Disposable>identityStrategy());
    private final TObjectIntHashMap<VirtualFilePointerImpl> myCounts = new TObjectIntHashMap<VirtualFilePointerImpl>();
    private final Disposable myParent;

    private DelegatingDisposable(@NotNull Disposable parent) {
      myParent = parent;
    }

    private static void registerDisposable(@NotNull Disposable parentDisposable, @NotNull VirtualFilePointerImpl pointer) {
      DelegatingDisposable result = ourInstances.get(parentDisposable);
      if (result == null) {
        DelegatingDisposable newDisposable = new DelegatingDisposable(parentDisposable);
        result = ConcurrencyUtil.cacheOrGet(ourInstances, parentDisposable, newDisposable);
        if (result == newDisposable) {
          Disposer.register(parentDisposable, result);
        }
      }

      synchronized (result) {
        result.myCounts.put(pointer, result.myCounts.get(pointer) + 1);
      }
    }

    @Override
    public void dispose() {
      ourInstances.remove(myParent);
      synchronized (this) {
        myCounts.forEachEntry(new TObjectIntProcedure<VirtualFilePointerImpl>() {
          @Override
          public boolean execute(VirtualFilePointerImpl pointer, int disposeCount) {
            int after = pointer.myNode.incrementUsageCount(-disposeCount + 1);
            LOG.assertTrue(after > 0, after);
            pointer.dispose();
            return true;
          }
        });
      }
    }
  }

  @TestOnly
  int numberOfPointers() {
    int number = 0;
    for (FilePointerPartNode root : myPointers.values()) {
      number = root.numberOfPointersUnder();
    }
    return number;
  }
  @TestOnly
  int numberOfListeners() {
    return myPointers.keySet().size();
  }
}


text:
using System;
using CjClutter.OpenGl;
using NUnit.Framework;
using FluentAssertions;
using OpenTK.Input;
using System.Linq;

namespace ObjLoader.Test
{
    [TestFixture]
    public class KeyDictionaryTests
    {
        [Test]
        public void Can_instantiate_the_dictionary()
        {
            Action act = () => new KeyDictionary();

            act.ShouldNotThrow();
        }

        [Test]
        public void Has_all_keys()
        {
            var keys = typeof (Key)
                .GetEnumValues()
                .Cast<Key>()
                .ToList();

            var keyDictionary = new KeyDictionary();

            foreach (var key in keys)
            {
                var key1 = key;
                Action act = () => { var b = keyDictionary[key1]; };

                act.ShouldNotThrow();
            }
        }

    }
}

redpajama_set_name: RedPajamaGithub


text:
layout: post
title: Faculty vacancy in Allahabad University last date 10th March-2016
date: 2016-02-02 12:27
comments: true
tags:  Faculty University UP
archive: false
---
Applications are invited for the Posts of Assistant Professor, Associate Professor,  Professor in various Departments of Faculties of Arts, Commerce, Law, Science and other independent Institutes / Centres of the University of Allahabad  :

- Professor : 49 posts, Pay Scale : Rs. 37400-67000 with AGP of Rs. 10000/-
- Associate Professor : 84 posts, Pay Scale : Rs. 37400-67000 with AGP of Rs. 9000/-
- Assistant Professor : 157 posts, Pay Scale : 15000-39100 with AGP of Rs. 6000/-

Application Fee :  DD of Rs. 500/- (Rs. 200/- for SC/ST  candidates) from any nationalized bank
drawn in favour of the Finance Officer, University of Allahabad and payable at Allahabad.

**How to Apply** : Application in the prescribed format completed in all respect along with relevant
documents, demand draft etc. as  required must reach the Registrar,
University of Allahabad, Allahabad - 211002  (U.P.) on or before 10/03/2016.

Please visit <http://www.allduniv.ac.in>  for details and  application format.


text:
class StateMachineError(Exception):
    """ Base error to be raise by the toolkit """

class TransitionError(StateMachineError):
    """ Raised if the transition or verification fails """

class UnreachableStateError(StateMachineError):
    """ Raised if state is not reachable """

class NonExistentStateError(StateMachineError):
    """ Raised when the transition is done to a state that was not registered """

class DeclarationError(StateMachineError):
    """ Raised if something is wrong with the state machine declaration in general """

class MultipleStatesError(StateMachineError):
    """ Raised when finding multiple states to transition to with a certain search criteria """


text:
At times I have needed to use or modify Dug Song's Fragroute. Figured it was due time to begin tracking those changes.

* Fragroute 1.2 uses an obsolete version of libevent and won't compile
out-of-the-box. I've hacked around that.
* Added ability to forward the original traffic to the destination but save
  the manipulated version of the traffic to a pcap file. Doing so means nothing
  fishy reaches the target host, but the would-be modified traffic is still saved for
  inspection, analysis, testing, etc.


text:
package gui;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.JPanel;

@SuppressWarnings("serial")
public class CanvasPanel extends JPanel{

	private static final int HEIGHT = 600;
	private static final int WIDTH = 600;

	private Color[][] colorMatrix;

	public CanvasPanel() {

		super();
		setPreferredSize( new Dimension(WIDTH, HEIGHT));
	}

	public void paintCanvas( Color[][] colorMatrix) {

		this.colorMatrix = colorMatrix;
		repaint();
	}

	@Override
	public void paintComponent(Graphics g) {

		super.paintComponent(g);

		if( colorMatrix != null) {

			for( int i = 0; i < colorMatrix.length; i++) {

				for( int j = 0; j < colorMatrix[0].length; j++) {

					g.setColor( colorMatrix[i][j]);
					g.drawLine(i, j, i, j);
				}
			}
		}
	}
}


text:
<page-header
    data-properties="{
        title   : 'Progress Bar',
        subtitle: 'Component',
        bg      : 'grey',
    }">
</page-header>

        <component
            data-properties="{
                title      : 'Default',
                templateUrl: 'docs/components/progress-bar/progress-bar-default.html'
            }">
        </component>

        <component
            data-properties="{
                title      : 'With Text',
                templateUrl: 'docs/components/progress-bar/progress-bar-with-text.html'
            }">
        </component>

        <component
            data-properties="{
                title      : 'Small',
                templateUrl: 'docs/components/progress-bar/progress-bar-small.html'
            }">
            Note:
            That size won't comport text inside
        </component>


text:
class XbeeCommand
{
    public:
        enum class returnType:uint8_t
        {
            NONE=0, BYTE=1, SHORT=2, WORD=4, LONG=8, RAW=9
        };

        XbeeCommand();
        XbeeCommand(const std::string cmd);
        XbeeCommand(const XbeePort::pinID port, const XbeePort::pinFunction pf = XbeePort::pinFunction::None);
        virtual ~XbeeCommand();

        virtual const std::string getCommand() { return cmd; }
        virtual const XbeePort::pinID getPort() { return port; }
        virtual const XbeePort::pinFunction getPortFunction() { return portFunction; }

        static std::string getCommandForPort(XbeePort::pinID port);
        static XbeePort::pinID getPortForCommand(std::string cmd);

    protected:

    private:
        std::string cmd;
        XbeePort::pinID port;
        XbeePort::pinFunction portFunction;
};

#endif // XBEECOMMAND_H


text:
var Crypto = require("tsugi-node/src/util/Crypto");
var PDOX = require("tsugi-node/src/util/PDOX");
var Q = require("q");

/**
 * This is a sample of the configuration file.  Copy this to
 * Config.js in the top directory and edit all the values to
 * set your Tsugi configuration.
 *
 *  Calling sequence in a NodeJS app:
 *
 *      var CFG = require('./Config');
 *      var Tsugi = require('./src/Tsugi');
 *
 *      launch = Tsugi.requireData(CFG, req, res, session, Tsugi.ALL);
 *      if ( launch.complete ) return;
 */
class Config {

    constructor() {

        /**
         * This is the URL where the software is hosted
         * Do not add a trailing slash to this string
         */
        this.wwwroot = 'http://localhost/tsugi';  /// For normal
        // this.wwwroot = 'http://localhost:8888/tsugi';   // For MAMP

        /**
         * Database connection information.
         */
        this.dbhost       = '127.0.0.1';
        this.dbname       = 'tsugi';
        // this.dbport       = 3306;
        this.dbport       = 8889; // MAMP
        /**
         * The database user (encrypted)
         * @type {string}
         */
        this._dbuser    = Crypto.encryptShortTerm('ltiuser');
        /**
         * The database password (encrypted)
         * @type {string}
         */
        this._dbpass    = Crypto.encryptShortTerm('ltipassword');

        /**
         * The dbprefix allows you to give all the tables a prefix
         * in case your hosting only gives you one database.  This
         * can be short like "t_" and can even be an empty string if you
         * can make a separate database for each instance of TSUGI.
         * This allows you to host multiple instances of TSUGI in a
         * single database if your hosting choices are limited.
         */
        this.dbprefix  = '';

        /**
         * You can use the CDN copy of the static content in testing or
         * light production.
         * If you check out a copy of the static content locally and do not
         * want to use the CDN copy (perhaps you are on a plane or are otherwise
         * not connected) change this configuration.
         */
         this.staticroot = 'https://www.dr-chuck.net/tsugi-static';
         // this.staticroot = this.wwwroot . "/../tsugi-static";

        /**
         * Where the bulk mail comes from - should be a real address with
         * a wildcard box you check
         */
        this.maildomain = false; // 'mail.example.com';
        /**
         * The mail secret (encrypted)
         * @type {string}
         */
        this._mailsecret = Crypto.encryptShortTerm('warning:please-change-mailsecret-92ds29');
        /**
         * Mail end of line - Depends on your mailer - may need to be \r\n
         */
        this.maileol = "\n";  // Depends on your mailer

        /**
         * Set the nonce clearing check proability
         */
        this.noncecheck = 100;
        /**
         * Set the nonce expiry time
         */
        this.noncetime = 1800;

        /**
         * This is used to make sure that our constructed session ids
         * based on resource_link_id, oauth_consumer_key, etc are not
         * predictable or guessable.   Just make this a long random string.
         * See LTIX::getCompositeKey() for detail on how this operates.
         */
        this.sessionsalt = "warning:please-change-sessionsalt-89b543";

        // Timezone
        this.timezone = 'Pacific/Honolulu'; // Nice for due dates

        // Universal Analytics
        this.universal_analytics = false; // "UA-57880800-1";

        // TODO: Make this work in Node - lots of fun
        // Only define this if you are using Tsugi in single standalone app that
        // will never be in iframes - because most browsers will *not* set cookies in
        // cross-domain iframes.   If you use this, you cannot be a different
        // user in a different tab or be in a different course in a different
        // tab.
        // if ( !defined('COOKIE_SESSION') ) define('COOKIE_SESSION', true);

        /**
         * Effectively an "airplane mode" for the appliction.
         * Setting this to true makes it so that when you are completely
         * disconnected, various tools will not access network resources
         * like Google's map library and hang.  Also the Google login will
         * be faked.  Don't run this in production.
         */
        this.OFFLINE = false;

        this.unitTesting = false;
        this.pdox = new PDOX(this);

        this.LTI = require('tsugi-node-lti/lib/ims-lti.js');

        // Check the tables (async - will fail later)
        let sql = this.pdox.setPrefix('SELECT * FROM {p}lti_key WHERE key_key = :key_key');
        this.pdox.allRows(sql,{ key_key: '12345' }).then(
            function(rows) {
                console.log("Table test success.");
            },
            function (err) {
                console.log('Could not load data query', sql);
                console.log('You need to install the Tsugi application console (a PHP app)');
                console.log('and use the Admin functionality to create the Tsugi tables');
                console.log('to initialize this application.');
                throw err;
            }
        );

    }

    /**
     * The database user (encrypted)
     * @type {string}
     */
    get dbuser() { return Crypto.decryptShortTerm(this._dbuser); }

    /**
     * The database password (encrypted)
     * @type {string}
     */
    get dbpass() { return Crypto.decryptShortTerm(this._dbpass); }

    /**
     * The mail secret (encrypted)
     * @type {string}
     */
    get mailsecret() { return Crypto.decryptShortTerm(this._mailsecret); }
}

module.exports = Config;


text:
package api_test

import (
	"net/http"
	"net/http/httptest"
	"time"

	testapi "github.com/cloudfoundry/cli/cf/api/fakes"
	testconfig "github.com/cloudfoundry/cli/testhelpers/configuration"
	testnet "github.com/cloudfoundry/cli/testhelpers/net"
	testterm "github.com/cloudfoundry/cli/testhelpers/terminal"

	"github.com/cloudfoundry/cli/cf/configuration/core_config"
	"github.com/cloudfoundry/cli/cf/errors"
	"github.com/cloudfoundry/cli/cf/models"
	"github.com/cloudfoundry/cli/cf/net"

	. "github.com/cloudfoundry/cli/cf/api"
	. "github.com/cloudfoundry/cli/testhelpers/matchers"

	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

var _ = Describe("Service Keys Repo", func() {
	var (
		testServer  *httptest.Server
		testHandler *testnet.TestHandler
		configRepo  core_config.ReadWriter
		repo        ServiceKeyRepository
	)

	setupTestServer := func(reqs ...testnet.TestRequest) {
		testServer, testHandler = testnet.NewServer(reqs)
		configRepo.SetApiEndpoint(testServer.URL)
	}

	BeforeEach(func() {
		configRepo = testconfig.NewRepositoryWithDefaults()
		configRepo.SetAccessToken("BEARER my_access_token")

		gateway := net.NewCloudControllerGateway(configRepo, time.Now, &testterm.FakeUI{})
		repo = NewCloudControllerServiceKeyRepository(configRepo, gateway)
	})

	Describe("CreateServiceKey", func() {
		It("makes the right request", func() {
			setupTestServer(testapi.NewCloudControllerTestRequest(testnet.TestRequest{
				Method:   "POST",
				Path:     "/v2/service_keys",
				Matcher:  testnet.RequestBodyMatcher(`{"service_instance_guid": "fake-instance-guid", "name": "fake-key-name"}`),
				Response: testnet.TestResponse{Status: http.StatusCreated},
			}))

			err := repo.CreateServiceKey("fake-instance-guid", "fake-key-name", nil)
			Expect(testHandler).To(HaveAllRequestsCalled())
			Expect(err).NotTo(HaveOccurred())
		})

		It("returns a ModelAlreadyExistsError if the service key exists", func() {
			setupTestServer(testapi.NewCloudControllerTestRequest(testnet.TestRequest{
				Method:  "POST",
				Path:    "/v2/service_keys",
				Matcher: testnet.RequestBodyMatcher(`{"service_instance_guid":"fake-instance-guid","name":"exist-service-key"}`),
				Response: testnet.TestResponse{
					Status: http.StatusBadRequest,
					Body:   `{"code":360001,"description":"The service key name is taken: exist-service-key"}`},
			}))

			err := repo.CreateServiceKey("fake-instance-guid", "exist-service-key", nil)
			Expect(testHandler).To(HaveAllRequestsCalled())
			Expect(err).To(BeAssignableToTypeOf(&errors.ModelAlreadyExistsError{}))
		})

		It("returns a NotAuthorizedError when CLI user is not the space developer or admin", func() {
			setupTestServer(testapi.NewCloudControllerTestRequest(testnet.TestRequest{
				Method:  "POST",
				Path:    "/v2/service_keys",
				Matcher: testnet.RequestBodyMatcher(`{"service_instance_guid":"fake-instance-guid","name":"fake-service-key"}`),
				Response: testnet.TestResponse{
					Status: http.StatusBadRequest,
					Body:   `{"code":10003,"description":"You are not authorized to perform the requested action"}`},
			}))

			err := repo.CreateServiceKey("fake-instance-guid", "fake-service-key", nil)
			Expect(testHandler).To(HaveAllRequestsCalled())
			Expect(err).To(HaveOccurred())
			Expect(err.Error()).To(ContainSubstring("You are not authorized to perform the requested action"))
		})

		Context("when there are parameters", func() {
			It("sends the parameters as part of the request body", func() {
				setupTestServer(testapi.NewCloudControllerTestRequest(testnet.TestRequest{
					Method:   "POST",
					Path:     "/v2/service_keys",
					Matcher:  testnet.RequestBodyMatcher(`{"service_instance_guid":"fake-instance-guid","name":"fake-service-key","parameters": {"data": "hello"}}`),
					Response: testnet.TestResponse{Status: http.StatusCreated},
				}))

				paramsMap := make(map[string]interface{})
				paramsMap["data"] = "hello"

				err := repo.CreateServiceKey("fake-instance-guid", "fake-service-key", paramsMap)
				Expect(testHandler).To(HaveAllRequestsCalled())
				Expect(err).NotTo(HaveOccurred())
			})

			Context("and there is a failure during serialization", func() {
				It("returns the serialization error", func() {
					paramsMap := make(map[string]interface{})
					paramsMap["data"] = make(chan bool)

					err := repo.CreateServiceKey("instance-name", "plan-guid", paramsMap)
					Expect(err).To(MatchError("json: unsupported type: chan bool"))
				})
			})
		})
	})

	Describe("ListServiceKeys", func() {
		It("returns empty result when no service key is found", func() {
			setupTestServer(testapi.NewCloudControllerTestRequest(testnet.TestRequest{
				Method:   "GET",
				Path:     "/v2/service_instances/fake-instance-guid/service_keys",
				Response: emptyServiceKeysResponse,
			}))

			serviceKeys, err := repo.ListServiceKeys("fake-instance-guid")
			Expect(testHandler).To(HaveAllRequestsCalled())
			Expect(err).NotTo(HaveOccurred())
			Expect(len(serviceKeys)).To(Equal(0))
		})

		It("returns correctly when service keys are found", func() {
			setupTestServer(testapi.NewCloudControllerTestRequest(testnet.TestRequest{
				Method:   "GET",
				Path:     "/v2/service_instances/fake-instance-guid/service_keys",
				Response: serviceKeysResponse,
			}))

			serviceKeys, err := repo.ListServiceKeys("fake-instance-guid")
			Expect(testHandler).To(HaveAllRequestsCalled())
			Expect(err).NotTo(HaveOccurred())
			Expect(len(serviceKeys)).To(Equal(2))

			Expect(serviceKeys[0].Fields.Guid).To(Equal("fake-service-key-guid-1"))
			Expect(serviceKeys[0].Fields.Url).To(Equal("/v2/service_keys/fake-guid-1"))
			Expect(serviceKeys[0].Fields.Name).To(Equal("fake-service-key-name-1"))
			Expect(serviceKeys[0].Fields.ServiceInstanceGuid).To(Equal("fake-service-instance-guid-1"))
			Expect(serviceKeys[0].Fields.ServiceInstanceUrl).To(Equal("http://fake/service/instance/url/1"))

			Expect(serviceKeys[0].Credentials).To(HaveKeyWithValue("username", "fake-username-1"))
			Expect(serviceKeys[0].Credentials).To(HaveKeyWithValue("password", "fake-password-1"))
			Expect(serviceKeys[0].Credentials).To(HaveKeyWithValue("host", "fake-host-1"))
			Expect(serviceKeys[0].Credentials).To(HaveKeyWithValue("port", float64(3306)))
			Expect(serviceKeys[0].Credentials).To(HaveKeyWithValue("database", "fake-db-name-1"))
			Expect(serviceKeys[0].Credentials).To(HaveKeyWithValue("uri", "mysql://fake-user-1:fake-password-1@fake-host-1:3306/fake-db-name-1"))

			Expect(serviceKeys[1].Fields.Guid).To(Equal("fake-service-key-guid-2"))
			Expect(serviceKeys[1].Fields.Url).To(Equal("/v2/service_keys/fake-guid-2"))
			Expect(serviceKeys[1].Fields.Name).To(Equal("fake-service-key-name-2"))
			Expect(serviceKeys[1].Fields.ServiceInstanceGuid).To(Equal("fake-service-instance-guid-2"))
			Expect(serviceKeys[1].Fields.ServiceInstanceUrl).To(Equal("http://fake/service/instance/url/1"))

			Expect(serviceKeys[1].Credentials).To(HaveKeyWithValue("username", "fake-username-2"))
			Expect(serviceKeys[1].Credentials).To(HaveKeyWithValue("password", "fake-password-2"))
			Expect(serviceKeys[1].Credentials).To(HaveKeyWithValue("host", "fake-host-2"))
			Expect(serviceKeys[1].Credentials).To(HaveKeyWithValue("port", float64(3306)))
			Expect(serviceKeys[1].Credentials).To(HaveKeyWithValue("database", "fake-db-name-2"))
			Expect(serviceKeys[1].Credentials).To(HaveKeyWithValue("uri", "mysql://fake-user-2:fake-password-2@fake-host-2:3306/fake-db-name-2"))
		})
	})

	Describe("GetServiceKey", func() {
		It("returns service key detail", func() {
			setupTestServer(testapi.NewCloudControllerTestRequest(testnet.TestRequest{
				Method:   "GET",
				Path:     "/v2/service_instances/fake-instance-guid/service_keys?q=name:fake-service-key-name",
				Response: serviceKeyDetailResponse,
			}))

			serviceKey, err := repo.GetServiceKey("fake-instance-guid", "fake-service-key-name")
			Expect(testHandler).To(HaveAllRequestsCalled())
			Expect(err).NotTo(HaveOccurred())

			Expect(serviceKey.Fields.Guid).To(Equal("fake-service-key-guid"))
			Expect(serviceKey.Fields.Url).To(Equal("/v2/service_keys/fake-guid"))
			Expect(serviceKey.Fields.Name).To(Equal("fake-service-key-name"))
			Expect(serviceKey.Fields.ServiceInstanceGuid).To(Equal("fake-service-instance-guid"))
			Expect(serviceKey.Fields.ServiceInstanceUrl).To(Equal("http://fake/service/instance/url"))

			Expect(serviceKey.Credentials).To(HaveKeyWithValue("username", "fake-username"))
			Expect(serviceKey.Credentials).To(HaveKeyWithValue("password", "fake-password"))
			Expect(serviceKey.Credentials).To(HaveKeyWithValue("host", "fake-host"))
			Expect(serviceKey.Credentials).To(HaveKeyWithValue("port", float64(3306)))
			Expect(serviceKey.Credentials).To(HaveKeyWithValue("database", "fake-db-name"))
			Expect(serviceKey.Credentials).To(HaveKeyWithValue("uri", "mysql://fake-user:fake-password@fake-host:3306/fake-db-name"))
		})

		It("returns empty result when the service key is not found", func() {
			setupTestServer(testapi.NewCloudControllerTestRequest(testnet.TestRequest{
				Method:   "GET",
				Path:     "/v2/service_instances/fake-instance-guid/service_keys?q=name:non-exist-key-name",
				Response: emptyServiceKeysResponse,
			}))

			serviceKey, err := repo.GetServiceKey("fake-instance-guid", "non-exist-key-name")
			Expect(testHandler).To(HaveAllRequestsCalled())
			Expect(err).NotTo(HaveOccurred())
			Expect(serviceKey).To(Equal(models.ServiceKey{}))
		})
	})

	Describe("DeleteServiceKey", func() {
		It("deletes service key successfully", func() {
			setupTestServer(testapi.NewCloudControllerTestRequest(testnet.TestRequest{
				Method: "DELETE",
				Path:   "/v2/service_keys/fake-service-key-guid",
			}))

			err := repo.DeleteServiceKey("fake-service-key-guid")
			Expect(testHandler).To(HaveAllRequestsCalled())
			Expect(err).NotTo(HaveOccurred())
		})
	})

	AfterEach(func() {
		testServer.Close()
	})
})

var emptyServiceKeysResponse = testnet.TestResponse{Status: http.StatusOK, Body: `{"resources": []}`}

var serviceKeysResponse = testnet.TestResponse{Status: http.StatusOK, Body: `{
	"resources": [
		{
	      "metadata": {
	        "guid": "fake-service-key-guid-1",
	        "url": "/v2/service_keys/fake-guid-1",
	        "created_at": "2015-01-13T18:52:08+00:00",
	        "updated_at": null
	      },
	      "entity": {
	        "name": "fake-service-key-name-1",
	        "service_instance_guid":"fake-service-instance-guid-1",
	        "service_instance_url":"http://fake/service/instance/url/1",
	        "credentials": {
	          "username": "fake-username-1",
	          "password": "fake-password-1",
	          "host": "fake-host-1",
	          "port": 3306,
	          "database": "fake-db-name-1",
	          "uri": "mysql://fake-user-1:fake-password-1@fake-host-1:3306/fake-db-name-1"
	        }
	      }
	    },
	    {
	      "metadata": {
	        "guid": "fake-service-key-guid-2",
	        "url": "/v2/service_keys/fake-guid-2",
	        "created_at": "2015-01-13T18:52:08+00:00",
	        "updated_at": null
	      },
	      "entity": {
	        "name": "fake-service-key-name-2",
	        "service_instance_guid":"fake-service-instance-guid-2",
	        "service_instance_url":"http://fake/service/instance/url/1",
	        "credentials": {
	          "username": "fake-username-2",
	          "password": "fake-password-2",
	          "host": "fake-host-2",
	          "port": 3306,
	          "database": "fake-db-name-2",
	          "uri": "mysql://fake-user-2:fake-password-2@fake-host-2:3306/fake-db-name-2"
	        }
	      }
	    }
	]}`,
}

var serviceKeyDetailResponse = testnet.TestResponse{Status: http.StatusOK, Body: `{
	"resources": [
		{
	      "metadata": {
	        "guid": "fake-service-key-guid",
	        "url": "/v2/service_keys/fake-guid",
	        "created_at": "2015-01-13T18:52:08+00:00",
	        "updated_at": null
	      },
	      "entity": {
	        "name": "fake-service-key-name",
	        "service_instance_guid":"fake-service-instance-guid",
	        "service_instance_url":"http://fake/service/instance/url",
	        "credentials": {
	          "username": "fake-username",
	          "password": "fake-password",
	          "host": "fake-host",
	          "port": 3306,
	          "database": "fake-db-name",
	          "uri": "mysql://fake-user:fake-password@fake-host:3306/fake-db-name"
	        }
	      }
		}]
	}`,
}


text:
/**
 * Created by MingYin Lv on 2017/2/24 下午10:06.
 */

import React, { Component, PropTypes as T } from 'react';
import moment from 'moment';
import { shouldComponentUpdate } from 'react-immutable-render-mixin';
import { Table, Card } from 'antd';
import { browserHistory } from 'react-router';
import { createUrl } from '../../../util/pathUtil';

const { Column } = Table;

class ListComponent extends Component {
  static propTypes = {
    loadArticleList: T.func.isRequired,
    dataSource: T.object.isRequired,
    typeList: T.object.isRequired,
    deleteArticleById: T.func.isRequired,
    loadTypeList: T.func.isRequired,
  };

  constructor(props) {
    super(props);
    this.shouldComponentUpdate = shouldComponentUpdate.bind(this);
    this.state = {
      dataSource: [],
    };
  }

  componentWillMount() {
    const { loadArticleList, loadTypeList, typeList } = this.props;
    loadArticleList();
    if (typeList.size <= 0) {
      loadTypeList();
    }
  }

  onLook = (index) => {
    return () => {
      console.log(index);
    };
  };

  onDelete = ({ _id }) => {
    const { deleteArticleById } = this.props;
    return () => {
      deleteArticleById(_id);
    };
  };

  onEdit = ({ _id }) => {
    return () => {
      browserHistory.push(createUrl(`/page/article/edit/${_id}`));
    };
  };

  renderOperate = (text, record, index) => {
    return (

        查看
        编辑
        删除

    );
  };

  render() {
    const { dataSource, typeList } = this.props;
    const typeMap = {};
    typeList.forEach((n) => {
      typeMap[n.get('_id')] = n.get('name');
    });
    const newData = dataSource.map((n) => {
      return n.set('type', typeMap[n.get('type_id')] || '未知')
        .set('updateDate', moment(n.get('updateDate'), 'x').format('YYYY-MM-DD HH:mm'));
    });

    return (
      <Card title="文章列表">

          <Column
            title="标题"
            dataIndex="title"
            key="title"
          />
          <Column
            title="作者"
            dataIndex="author"
            key="author"
          />
          <Column
            title="最后更新时间"
            dataIndex="updateDate"
            key="updateDate"
          />
          <Column
            title="访问统计"
            dataIndex="accessTotal"
            key="accessTotal"
          />
          <Column
            title="分类"
            dataIndex="type"
            key="type"
          />
          <Column
            title="操作"
            key="operate"
            render={this.renderOperate}
          />

      </Card>
    );
  }
}

export default ListComponent;


text:
class SkBitmap;

namespace content {

class LayoutTestControllerHost : public RenderViewHostObserver {
 public:
  static LayoutTestControllerHost* FromRenderViewHost(
      RenderViewHost* render_view_host);

  // Initialize the LayoutTestControllerHost for a given test.
  static void Init(const std::string& expected_pixel_hash);

  explicit LayoutTestControllerHost(RenderViewHost* render_view_host);
  virtual ~LayoutTestControllerHost();

  bool should_stay_on_page_after_handling_before_unload() const {
    return should_stay_on_page_after_handling_before_unload_;
  }

  // RenderViewHostObserver implementation.
  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;

 private:
  void CaptureDump();
  void TimeoutHandler();

  // Message handlers.
  void OnDidFinishLoad();
  void OnTextDump(const std::string& dump);
  void OnImageDump(const std::string& actual_pixel_hash, const SkBitmap& image);

  // layoutTestController handlers.
  void OnNotifyDone();
  void OnDumpAsText();
  void OnDumpChildFramesAsText();
  void OnSetPrinting();
  void OnSetShouldStayOnPageAfterHandlingBeforeUnload(bool should_stay_on_page);
  void OnWaitUntilDone();

  void OnNotImplemented(const std::string& object_name,
                        const std::string& method_name);

  static std::map<RenderViewHost*, LayoutTestControllerHost*> controllers_;
  static std::string expected_pixel_hash_;

  bool captured_dump_;

  bool dump_as_text_;
  bool dump_child_frames_;
  bool is_printing_;
  bool should_stay_on_page_after_handling_before_unload_;
  bool wait_until_done_;

  base::CancelableClosure watchdog_;

  DISALLOW_COPY_AND_ASSIGN(LayoutTestControllerHost);
};

}  // namespace content

#endif  // CONTENT_SHELL_LAYOUT_TEST_CONTROLLER_HOST_H_


text:
classdef SimulationTimepointsTest < matlab.unittest.TestCase

    properties
        test_dir = [pwd '\..\..\perturbation_tests\to_be_reformatted\math_L-curve\']
        GRNstruct
    end

    methods (TestClassSetup)
        function addPath (testCase)
            testCase.GRNstruct.inputFile = [testCase.test_dir '\4-genes_6-edges_artificial-data_Sigmoidal_estimation_fixb-1_fixP-1_no-graph_test1.xlsx'];
            testCase.GRNstruct = readInputSheet(testCase.GRNstruct);
        end
    end

    methods (Test)
        function testSimulationTimepoints(testCase)
            expected_timepoints = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
            for sheet = 1:length(testCase.GRNstruct.expressionData)
                timepoints = [];
                for repetitions = 1:size(testCase.GRNstruct.expressionData(sheet).t, 2);
                    timepoints = [timepoints testCase.GRNstruct.expressionData(sheet).t(repetitions).indx];
                end
                missing_cols = setdiff(expected_timepoints, timepoints);
                testCase.verifyEqual(missing_cols, zeros(1,0));
            end
        end

        function testSimTimepointsLength(testCase)
            cols_in_sheets = [12,12];
            for sheet = 1:length(testCase.GRNstruct.expressionData)
                count = 0;
                for timepoint = 1:size(testCase.GRNstruct.expressionData(sheet).t,2)
                    count = count + length(testCase.GRNstruct.expressionData(sheet).t(timepoint).indx);
                end
                testCase.verifyEqual(count,cols_in_sheets(sheet));
            end
        end
    end
end


text:
using BearLib;
using System;
using System.Drawing;

namespace Roguelike.UI
{
    public class MenuItem
    {
        public static Color DefaultColour { get; } = Color.White;
        public static Color HighlightedColour { get; } = Color.Yellow;
        public static Color DisabledColour { get; } = Color.Silver;

        public string Text { get; set; }
        public Action OnSelected { get; set; }
        public bool IsEnabled { get; set; } = true;

        public void Select()
        {
            OnSelected?.Invoke();
        }

        public void Draw(int x, int y, bool highlighted)
        {
            if (IsEnabled)
            {
                if (highlighted)
                {
                    Terminal.Color(HighlightedColour);
                    Terminal.PutExt(x - 1, y, -8, 0, 0x2192);
                }
                else
                {
                    Terminal.Color(DefaultColour);
                }
            }
            else
            {
                Terminal.Color(DisabledColour);
            }

            Terminal.Print(x, y, Text);
        }
    }

    public class MenuItem<T>
    {
        public static Color DefaultColour { get; } = Color.White;
        public static Color HighlightedColour { get; } = Color.Yellow;
        public static Color DisabledColour { get; } = Color.Silver;

        public string Text { get; set; }
        public Func<T> OnSelected { get; set; }
        public bool IsEnabled { get; set; } = true;

        public T Select()
        {
            if (OnSelected != null)
            {
                return OnSelected();
            }

            return default(T);
        }

        public void Draw(int x, int y, bool highlighted)
        {
            if (IsEnabled)
            {
                if (highlighted)
                {
                    Terminal.Color(HighlightedColour);
                    Terminal.PutExt(x - 1, y, -8, 0, 0x2192);
                }
                else
                {
                    Terminal.Color(DefaultColour);
                }
            }
            else
            {
                Terminal.Color(DisabledColour);
            }

            Terminal.Print(x, y, Text);
        }
    }
}


text:
<?php

return [
    'rules' => [
        'psr0' => false,
        '@PSR2' => true,
        'blank_line_after_namespace' => true,
        'braces' => true,
        'class_definition' => true,
        'elseif' => true,
        'function_declaration' => true,
        'indentation_type' => true,
        'line_ending' => true,
        'lowercase_constants' => true,
        'lowercase_keywords' => true,
        'method_argument_space' => [
            'ensure_fully_multiline' => true, ],
        'no_break_comment' => true,
        'no_closing_tag' => true,
        'no_spaces_after_function_name' => true,
        'no_spaces_inside_parenthesis' => true,
        'no_trailing_whitespace' => true,
        'no_trailing_whitespace_in_comment' => true,
        'single_blank_line_at_eof' => true,
        'single_class_element_per_statement' => [
            'elements' => ['property'],
        ],
        'single_import_per_statement' => true,
        'single_line_after_imports' => true,
        'switch_case_semicolon_to_colon' => true,
        'switch_case_space' => true,
        'visibility_required' => true,
        'encoding' => true,
        'full_opening_tag' => true,
        ],
];


text:
from __future__ import absolute_import
from __future__ import print_function

from .nodes import *
from .selectors import *
from .values import *
from .expressions import *
from .operators import *

from .util import *


text:
<?php

namespace Tests\Socialite;

use Tests\TestCase;
use Mockery as m;
use Laravel\Socialite\Two\User as TwoUser;

class OlxProviderTest extends TestCase
{
    public function setUp()
    {
        parent::setUp();
        $this->request = m::mock('Illuminate\Http\Request');
        $this->clientId = 'abcdef';
        $this->redirectUrl = 'http://localhost/redirect';
        $this->clientSecret = '123456';
        $this->olx = new OlxStub($this->request, $this->clientId, $this->clientSecret, $this->redirectUrl);
    }

    public function testImplements()
    {
        $this->assertInstanceOf('Laravel\Socialite\Two\AbstractProvider', $this->olx);
        $this->assertInstanceOf('Laravel\Socialite\Two\ProviderInterface', $this->olx);
        $this->assertAttributeEquals(['basic_user_info'], 'scopes', $this->olx);
    }

    public function testGetTokenUrlImplementRedirect()
    {
        $state = '';
        $session = m::mock('session');
        $session->shouldreceive('set')->once();

        $this->request->shouldreceive('session')->once()->andReturn($session);

        $response = $this->olx->redirect();

        $this->assertInstanceOf('Symfony\Component\HttpFoundation\RedirectResponse', $response);

        $url = 'https://auth.olx.com.br/oauth?';
        $url .= 'client_id=%s&redirect_uri=%s';
        $url .= '&scope=basic_user_info';
        $url .= '&response_type=code';
        $url .= '&state=';
        $pattern = preg_quote($url, '/');
        $pattern = sprintf("/^{$pattern}[a-zA-Z0-9]{40}$/", $this->clientId, urlencode($this->redirectUrl));
        $this->assertRegExp($pattern, $response->getTargetUrl());
    }

    public function testImplementAccessTokenResponse()
    {
        $tokeUrl = 'https://auth.olx.com.br/oauth/token';
        $postKey = (version_compare(\GuzzleHttp\ClientInterface::VERSION, '6') === 1) ? 'form_params' : 'body';
        $data = [
            'headers' => ['Accept' => 'application/json'],
            $postKey => [
                'code' => 'code123',
                'client_id' => $this->clientId,
                'client_secret' => $this->clientSecret,
                'redirect_uri' => $this->redirectUrl,
                'grant_type' => 'authorization_code',
            ],
        ];

        $response = m::mock('StdClass');
        $response->shouldreceive('getBody')->once()->andReturn('{"foo":"bar"}');

        $this->olx->getHttpClient()
            ->shouldreceive('post')
            ->once()
            ->with($tokeUrl, $data)
            ->andReturn($response);

        $this->assertEquals(['foo' => 'bar'], $this->olx->getAccessTokenResponse('code123'));
    }

    public function testUserFromToken()
    {
        $data = ['user_email' => 'user@email.com', 'user_name' => 'UserOlx'];
        $response = m::mock('StdClass');
        $response->shouldreceive('getBody')->once()->andReturn(json_encode($data));

        $token = 'asdfghjkl';
        $userUrl = 'https://apps.olx.com.br/oauth_api/basic_user_info?access_token='.$token;

        $this->olx->getHttpClient()
            ->shouldreceive('get')
            ->once()
            ->with($userUrl)
            ->andReturn($response);

        $userExpected = new TwoUser;
        $userExpected->setRaw($data);
        $userExpected->id = $data['user_email'];
        $userExpected->name = $data['user_name'];
        $userExpected->email = $data['user_email'];
        $userExpected->token = $token;

        $this->assertEquals($userExpected, $this->olx->userFromToken($token));
    }
}

class OlxStub extends \NwLaravel\Socialite\OlxProvider
{
    public $http;

    /**
     * Get a fresh instance of the Guzzle HTTP client.
     *
     * @return \GuzzleHttp\Client
     */
    public function getHttpClient()
    {
        if ($this->http) {
            return $this->http;
        }

        return $this->http = m::mock('StdClass');
    }
}


text:
/**
 * Provides a date range input field with a {@link Genapp.DateRangePicker} dropdown and automatic date validation.
 *
 * @class Genapp.form.DateRangeField
 * @extends Ext.form.DateField
 * @constructor Create a new DateRangeField
 * @param {Object} config
 * @xtype daterangefield
 */

Ext.namespace('Genapp.form');

Genapp.form.DateRangeField = Ext.define("Ext.ux.DateRange", {
    extend: 'Ext.form.field.Date',
    /**
     * @cfg {String} minText
     * The error text to display when the date in the cell is before <tt>{@link #minValue}</tt> (defaults to
     * <tt>'The date in this field must be after {minValue}'</tt>).
     */
    minText: "The dates in this field must be equal to or after {0}",
    /**
     * @cfg {String} maxText
     * The error text to display when the date in the cell is after <tt>{@link #maxValue}</tt> (defaults to
     * <tt>'The date in this field must be before {maxValue}'</tt>).
     */
    maxText: "The dates in this field must be equal to or before {0}",
    /**
     * @cfg {String} reverseText
     * The error text to display when the dates are reversed (defaults to
     * <tt>'The end date must be posterior to the start date'</tt>).
     */
    reverseText: "The end date must be posterior to the start date",
    /**
     * @cfg {String} notEqualText
     * The error text to display when the dates are equal (defaults to
     * <tt>'The end date can't be equal to the start date'</tt>).
     */
    notEqualText: "The end date can't be equal to the start date",
    /**
     * @cfg {String} dateSeparator
     * The separator text to display between the dates (defaults to <tt>' - '</tt>)
     */
    dateSeparator: ' - ',
    /**
     * @cfg {String} endDatePrefix
     * The prefix for the end date (defaults to <tt>'<= '</tt>)
     */
    endDatePrefix: '<= ',
    /**
     * @cfg {String} startDatePrefix
     * The prefix for the start date (defaults to <tt>'>= '</tt>)
     */
    startDatePrefix: '>= ',
    /**
     * @cfg {Boolean} usePrefix if true, endDatePrefix and startDatePrefix are used (defaults to true).
     * Otherwise minValue and maxValue are used.
     */
    usePrefix: true,
    /**
     * @cfg {Boolean} hideValidationButton if true, hide the menu validation button (defaults to false).
     */
    hideValidationButton : false,
    /**
     * @cfg {Boolean} authorizeEqualValues if true, a unique value
     * can be entered for the min and the max values.
     * If false, the min and max values can't be equal (defaults to true).
     */
    authorizeEqualValues : true,
    /**
     * @cfg {Boolean} mergeEqualValues if true and if the max and min values
     * are equal, an unique value will be displayed instead of the min and max values.
     * (authorizeEqualValues must be set to true)
     * If false, the min and max values are displayed normally even if they are equals (defaults to true).
     */
    mergeEqualValues : true,
    /**
     * @cfg {Boolean} autoReverse if true, reverse the min and max values if max < min (defaults to true).
     */
    autoReverse : true,
    /**
     * @cfg {Date/String} minValue
     * The minimum allowed date. Can be either a Javascript date object or a string date in a
     * valid format (defaults to 'new Date(0)').
     */
    minValue : new Date(0),
    /**
     * @cfg {Date/String} maxValue
     * The maximum allowed date. Can be either a Javascript date object or a string date in a
     * valid format (defaults to 'new Date(2999,11,31)').
     */
    maxValue : new Date(2999,11,31),
    /**
     * @cfg {Date/String} minDefaultValue
     * The minimum default date. Can be either a Javascript date object or a string date in a
     * valid format (defaults to 'new Date()').
     */
    minDefaultValue : new Date(),
    /**
     * @cfg {Date/String} maxDefaultValue
     * The maximum default date. Can be either a Javascript date object or a string date in a
     * valid format (defaults to 'new Date()').
     */
    maxDefaultValue : new Date(),

    /**
     * Replaces any existing disabled dates with new values and refreshes the DateRangePicker.
     * @param {Array} disabledDates An array of date strings (see the <tt>{@link #disabledDates}</tt> config
     * for details on supported values) used to disable a pattern of dates.
     */
    setDisabledDates : function(dd){
        this.disabledDates = dd;
        this.initDisabledDays();
        if(this.menu){
            this.menu.rangePicker.startDatePicker.setDisabledDates(this.disabledDatesRE);
            this.menu.rangePicker.endDatePicker.setDisabledDates(this.disabledDatesRE);
        }
    },

    /**
     * Replaces any existing disabled days (by index, 0-6) with new values and refreshes the DateRangePicker.
     * @param {Array} disabledDays An array of disabled day indexes. See the <tt>{@link #disabledDays}</tt>
     * config for details on supported values.
     */
    setDisabledDays : function(dd){
        this.disabledDays = dd;
        if(this.menu){
            this.menu.rangePicker.startDatePicker.setDisabledDays(dd);
            this.menu.rangePicker.endDatePicker.setDisabledDays(dd);
        }
    },

    /**
     * Replaces any existing <tt>{@link #minValue}</tt> with the new value and refreshes the DateRangePicker.
     * @param {Date} value The minimum date that can be selected
     */
    setMinValue : function(dt){
        this.minValue = (typeof dt == "string" ? this.parseDate(dt) : dt);
        if(this.menu){
            this.menu.rangePicker.startDatePicker.setMinDate(this.minValue);
            this.menu.rangePicker.endDatePicker.setMinDate(this.minValue);
        }
    },

    /**
     * Replaces any existing <tt>{@link #maxValue}</tt> with the new value and refreshes the DateRangePicker.
     * @param {Date} value The maximum date that can be selected
     */
    setMaxValue : function(dt){
        this.maxValue = (typeof dt == "string" ? this.parseDate(dt) : dt);
        if(this.menu){
            this.menu.rangePicker.startDatePicker.setMaxDate(this.maxValue);
            this.menu.rangePicker.endDatePicker.setMaxDate(this.maxValue);
        }
    },

    /**
     * Runs all of NumberFields validations and returns an array of any errors. Note that this first
     * runs TextField's validations, so the returned array is an amalgamation of all field errors.
     * The additional validation checks are testing that the date format is valid, that the chosen
     * date is within the min and max date constraints set, that the date chosen is not in the disabledDates
     * regex and that the day chosed is not one of the disabledDays.
     * @param {Mixed} value The value to get errors for (defaults to the current field value)
     * @return {Array} All validation errors for this field
     */
    getErrors: function(value) {
        var errors = Ext.form.DateField.superclass.getErrors.apply(this, arguments);

        value = this.formatDate(value || this.processValue(this.getRawValue()));

        if (value.length < 1){ // if it's blank and textfield didn't flag it then it's valid
             return errors;
        }
        var values = value.split(this.dateSeparator);
        if (values.length != 1 && values.length != 2){
            errors.push(String.format(this.invalidText, value, this.format+this.dateSeparator+this.format));
            return errors;
        }
        var rangeDate = this.parseRangeDate(value);
        if(values.length == 1){
            if (!rangeDate){
                errors.push(String.format(this.invalidText, value, this.format));
                return errors;
            }
            var scErrors = Ext.form.DateField.superclass.getErrors.call(this, value);
            if (!Ext.isEmpty(scErrors)){
                errors.push(String.format(this.invalidText, value, this.format));
                return errors;
            }
        }else if(values.length == 2){
            if (!rangeDate){
                errors.push(String.format(this.invalidText, value, this.format+this.dateSeparator+this.format));
                return errors;
            }
            var scErrors = Ext.form.DateField.superclass.getErrors.call(this, value);
            if (!Ext.isEmpty(scErrors)){
                errors.push(String.format(this.invalidText, value, this.format+this.dateSeparator+this.format));
                return errors;
            }
            if (rangeDate.endDate.getTime() - rangeDate.startDate.getTime() < 0){
                errors.push(this.reverseText);
                return errors;
            }
            if (!this.authorizeEqualValues && rangeDate.endDate.getElapsed(rangeDate.startDate) == 0){
                errors.push(this.notEqualText);
                return errors;
            }
        }
        //Checks if the start date is in the interval [minDate,maxDate]
        if (rangeDate.startDate != null){
            if (rangeDate.startDate.getTime() - this.minValue.getTime() < 0){
                errors.push(String.format(this.minText, this.formatDate(this.minValue)));
                return errors;
            }
            if (this.maxValue.getTime() - rangeDate.startDate.getTime() < 0){
                errors.push(String.format(this.maxText, this.formatDate(this.maxValue)));
                return errors;
            }
        }
        //Checks if the end date is in the interval [minDate,maxDate]
        if (rangeDate.endDate != null){
            if (rangeDate.endDate.getTime() - this.minValue.getTime() < 0){
                errors.push(String.format(this.minText, this.formatDate(this.minValue)));
                return errors;
            }
            if (this.maxValue.getTime() - rangeDate.endDate.getTime() < 0){
                errors.push(String.format(this.maxText, this.formatDate(this.maxValue)));
                return errors;
            }
        }
        return errors;
    },

    // private
    // return a range date object or null for failed parse operations
    parseRangeDate : function(value){
        if(!value){
            return null;
        }
        if(this.isRangeDate(value)){
            return value;
        }
        if(Ext.isDate(value)){
            return {startDate:value, endDate:value};
        }
        var values = value.split(this.dateSeparator);
        if(values.length == 1){
            var sdpIndex = value.indexOf(this.startDatePrefix,0);
            var edpIndex = value.indexOf(this.endDatePrefix,0);
            if(sdpIndex != -1){
            // Case ">= YYYY/MM/DD"
                var startDate = this.parseDate.call(this, value.substring(sdpIndex + this.startDatePrefix.length));
                if(startDate){
                    return {startDate:startDate, endDate:null};
                }else{
                    return null;
                }
            }else if(edpIndex != -1){
            // Case "<= YYYY/MM/DD"
                var endDate = this.parseDate.call(this, value.substring(edpIndex + this.endDatePrefix.length));
                if(endDate){
                    return {startDate:null, endDate:endDate};
                }else{
                    return null;
                }
            }else{
            // Case "YYYY/MM/DD"
                var date = this.parseDate.call(this, value);
                if(date){
                    return {startDate:date, endDate:date};
                }else{
                    return null;
                }
            }
        }else if(values.length == 2){
            // Case "YYYY/MM/DD - YYYY/MM/DD"
            var sv = Date.parseDate(values[0], this.format);
            var ev = Date.parseDate(values[1], this.format);
            if((!sv || !ev) && this.altFormats){
                if(!this.altFormatsArray){
                    this.altFormatsArray = this.altFormats.split("|");
                }
                var i,len;
                if(!sv){
                    for(i = 0, len = this.altFormatsArray.length; i < len && !sv; i++){
                        sv = Date.parseDate(values[0], this.altFormatsArray[i]);
                    }
                }
                if(!ev){
                    for(i = 0, len = this.altFormatsArray.length; i < len && !ev; i++){
                        ev = Date.parseDate(values[1], this.altFormatsArray[i]);
                    }
                }
            }
            if(!sv || !ev){
                return null;
            }else{
                return {startDate:sv, endDate:ev};
            }
        }else{
            return null;
        }
    },

    // private
    formatDate : function(date){
        if(Ext.isDate(date)){
            return Genapp.form.DateRangeField.superclass.formatDate.call(this, date);
        }
        if(this.isRangeDate(date)){
            if(date.startDate == null && date.endDate != null){
                if(this.usePrefix){
                    return this.endDatePrefix + date.endDate.format(this.format);
                }else{
                    return this.minValue.format(this.format) + this.dateSeparator + date.endDate.format(this.format);
                }
            }else if(date.startDate != null && date.endDate == null){
                if(this.usePrefix){
                    return this.startDatePrefix + date.startDate.format(this.format);
                }else{
                    return date.startDate.format(this.format) + this.dateSeparator + this.maxValue.format(this.format);
                }
            }else if(date.startDate != null && date.endDate != null){
                if(this.mergeEqualValues && date.endDate.getElapsed(date.startDate) == 0){
                    return date.startDate.format(this.format);
                }else if(this.autoReverse && date.endDate.getTime() - date.startDate.getTime() < 0){
                    return date.endDate.format(this.format) + this.dateSeparator + date.startDate.format(this.format);
                }else{
                    return date.startDate.format(this.format) + this.dateSeparator + date.endDate.format(this.format);
                }
            }else{
                return '';
            }
        }else{
            return date;
        }
    },

    /**
     * The function that handle the trigger's click event.
     * Implements the default empty TriggerField.onTriggerClick function to display the DateRangePicker
     * @method onTriggerClick
     * @hide
     */
    onTriggerClick : function(){
        if(this.disabled){
            return;
        }
        if(!this.menu){
            /**
             * The field menu (displayed on a trigger click).
             * @property menu
             * @type Genapp.menu.DateRangeMenu
             */
            this.menu = new Genapp.menu.DateRangeMenu({
                hideOnClick: false,
                hideValidationButton: this.hideValidationButton,
                showToday: this.showToday
            });
        }
        this.onFocus();
        if(typeof this.minDefaultValue === 'string'){
            this.minDefaultValue = new Date(this.minDefaultValue);
        }
        if(typeof this.maxDefaultValue === 'string'){
            this.maxDefaultValue = new Date(this.maxDefaultValue);
        }
        Ext.apply(this.menu.rangePicker.startDatePicker,  {
            minDate : this.minValue,
            maxDate : this.maxValue,
            defaultValue : this.minDefaultValue,
            disabledDatesRE : this.disabledDatesRE,
            disabledDatesText : this.disabledDatesText,
            disabledDays : this.disabledDays,
            disabledDaysText : this.disabledDaysText,
            format : this.format,
            showToday : this.showToday,
            minText : String.format(this.minText, this.formatDate(this.minValue)),
            maxText : String.format(this.maxText, this.formatDate(this.maxValue))
        });
        Ext.apply(this.menu.rangePicker.endDatePicker,  {
            minDate : this.minValue,
            maxDate : this.maxValue,
            defaultValue : this.maxDefaultValue,
            disabledDatesRE : this.disabledDatesRE,
            disabledDatesText : this.disabledDatesText,
            disabledDays : this.disabledDays,
            disabledDaysText : this.disabledDaysText,
            format : this.format,
            showToday : this.showToday,
            minText : String.format(this.minText, this.formatDate(this.minValue)),
            maxText : String.format(this.maxText, this.formatDate(this.maxValue))
        });

        var values = this.getValue();
        var minv = this.minDefaultValue;
        var maxv = this.maxDefaultValue;
        if(Ext.isDate(values)){
            minv = values;
            maxv = values;
        }else if(this.isRangeDate(values)){
            if(values.startDate != null){
                minv = values.startDate;
            }
            if(values.endDate != null){
                maxv = values.endDate;
            }
        }

        this.menu.rangePicker.startDatePicker.setValue(minv);
        this.menu.rangePicker.endDatePicker.setValue(maxv);

        this.menu.show(this.el, "tl-bl?");
        this.menuEvents('on');
    },

    /**
     * Checks if the object is a correct range date
     * @param {Object} rangeDate The rangeDate to check.

     * An object containing the following properties:

     *

startDate : Date
the start date

     *
endDate : Date
the end date

     * @return {Boolean} true if the object is a range date
     */
    isRangeDate : function(rangeDate){
        return (Ext.isObject(rangeDate) && (Ext.isDate(rangeDate.startDate) || rangeDate.startDate == null) && (Ext.isDate(rangeDate.endDate) || rangeDate.endDate == null));
    },

    /**
     * Returns the current date value of the date field.
     * @return {Date} The date value
     */
    getValue : function(){
        return this.parseRangeDate(Ext.form.DateField.superclass.getValue.call(this)) || "";
    },

    /**
     * Sets the value of the date field.  You can pass a date object or any string that can be
     * parsed into a valid date, using <tt>{@link #format}</tt> as the date format, according
     * to the same rules as {@link Date#parseDate} (the default format used is <tt>"m/d/Y"</tt>).
     *
Usage:
     *

//All of these calls set the same date value (May 4, 2006)

//Pass a date object:
var dt = new Date('5/4/2006');
dateField.setValue(dt);

//Pass a date string (default format):
dateField.setValue('05/04/2006');

//Pass a date string (custom format):
dateField.format = 'Y-m-d';
dateField.setValue('2006-05-04');

     * @param {String/Date} date The date or valid date string
     * @return {Ext.form.Field} this
     */
    setValue : function(date){
        return Ext.form.DateField.superclass.setValue.call(this, this.formatDate(this.parseRangeDate(date)));
    },

    // private
    beforeBlur : function(){
        var v = this.parseRangeDate(this.getRawValue());
        if(v){
            this.setValue(v);
        }
    }
});
/**
 *
 * A menu containing a {@link Genapp.DateRangePicker} Component.
 *
 * @class Genapp.menu.DateRangeMenu
 * @extends Ext.menu.DateMenu
 * @constructor Create a new DateRangeMenu
 * @param {Object} config
 * @xtype daterangemenu
 */

Ext.namespace('Genapp.menu');

Genapp.menu.DateRangeMenu = Ext.define("Ext.ux.DateRangeMenu", {
    extend: 'Ext.menu.DatePicker',
    /**
     * @cfg {String/Object} layout
     * Specify the layout manager class for this container either as an Object or as a String.
     * See {@link Ext.Container#layout layout manager} also.
     * Default to 'table'.
     * Note: The layout 'menu' doesn't work on FF3.5,
     * the rangePicker items are not rendered
     * because the rangePicker is hidden...
     * But it's working on IE ???
     */
    layout:'table',
    /**
     * @cfg {String} cls
     * An optional extra CSS class that will be added to this component's Element (defaults to 'x-date-range-menu').
     * This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
     */
    cls: 'x-date-range-menu',

    // private
    initComponent: function(){
        this.on('beforeshow', this.onBeforeShow, this);
        /**
         * The {@link Genapp.DateRangePicker} instance for this DateRangeMenu
         * @property rangePicker
         * @type Genapp.DateRangePicker
         */
        Ext.apply(this, {
            plain: true,
            showSeparator: false,
            items: [this.rangePicker = new Genapp.DateRangePicker(this.initialConfig)]
        });
        this.rangePicker.purgeListeners();
        Ext.menu.DateMenu.superclass.initComponent.call(this);
        this.relayEvents(this.rangePicker, ["select"]);
    },

    // private
    onBeforeShow: function(){
        if (this.rangePicker){
            this.rangePicker.startDatePicker.hideMonthPicker(true);
            this.rangePicker.endDatePicker.hideMonthPicker(true);
        }
    },

    /**
     * Displays this menu at a specific xy position
     * @param {Array} xyPosition Contains X & Y [x, y] values for the position at which to show the menu (coordinates are page-based)
     * @param {Ext.menu.Menu} parentMenu (optional) This menu's parent menu, if applicable (defaults to undefined)
     */
    showAt : function(xy, parentMenu, /* private: */_e){
        this.parentMenu = parentMenu;
        if(!this.el){
            this.render();
        }
        if(_e !== false){
            this.fireEvent("beforeshow", this);
            xy = this.el.adjustForConstraints(xy);
        }
        this.el.setXY(xy);
        if(this.enableScrolling){
            this.constrainScroll(xy[1]);
        }
        this.el.show();
        Ext.menu.Menu.superclass.onShow.call(this);
        this.hidden = false;
        this.focus();
        this.fireEvent("show", this);
    }
});
/**
 * Simple date range picker class.
 *
 * @class Genapp.DateRangePicker
 * @extends Ext.Panel
 * @constructor Create a new DateRangePicker
 * @param {Object} config The config object
 * @xtype daterangepicker
 */

Ext.namespace('Genapp');

Genapp.DateRangePicker = Ext.define("Genapp.DateRangePicker", {
    extend: 'Ext.panel.Panel',
    /**
     * @cfg {String/Object} layout
     * Specify the layout manager class for this container either as an Object or as a String.
     * See {@link Ext.Container#layout layout manager} also.
     * Default to 'column'.
     */
    layout: 'column',
    /**
     * @cfg {String} cls
     * An optional extra CSS class that will be added to this component's Element (defaults to 'x-menu-date-range-item').
     * This can be useful for adding customized styles to the component or any of its children using standard CSS rules.
     */
    cls: 'x-menu-date-range-item',
    /**
     * @cfg {String} buttonAlign
     * The alignment of any {@link #buttons} added to this panel.  Valid values are 'right',
     * 'left' and 'center' (defaults to 'center').
     */
    buttonAlign: 'center',
    /**
     * @cfg {Boolean} hideValidationButton if true hide the menu validation button (defaults to false).
     */
    hideValidationButton : false,
    /**
     * @cfg {String} tbarStartDateButtonText
     * The tbar start date button text (defaults to <tt>'Start Date ...'</tt>)
     */
    tbarStartDateButtonText:'Start Date ...',
    /**
     * @cfg {String} tbarRangeDateButtonText
     * The tbar range date button text (defaults to <tt>'Range Date'</tt>)
     */
    tbarRangeDateButtonText:'Range Date',
    /**
     * @cfg {String} tbarEndDateButtonText
     * The tbar end date button text (defaults to <tt>'... End Date'</tt>)
     */
    tbarEndDateButtonText:'... End Date',
    /**
     * @cfg {String} fbarOkButtonText
     * The fbar ok button text (defaults to <tt>'ok'</tt>)
     */
    fbarOkButtonText:'ok',
    /**
     * The selected dates (Default to '{startDate:null, endDate:null}'). Read-only.
     * @type Object
     * @property selectedDate
     */
    selectedDate: {startDate:null, endDate:null},

    // private
    initComponent : function(){
        this.items = [
            /**
             * The start date picker (The left picker).
             * @property startDatePicker
             * @type Ext.DatePicker
             */
            this.startDatePicker = new Ext.DatePicker(Ext.apply({
                internalRender: this.strict || !Ext.isIE,
                ctCls: 'x-menu-date-item',
                columnWidth: .5
                }, this.initialConfig)
            ),{
                xtype:'spacer',
                width:5,
                html:' ' // For FF and IE8
            },
            /**
             * The end date picker (The right picker).
             * @property endDatePicker
             * @type Ext.DatePicker
             */
            this.endDatePicker = new Ext.DatePicker(Ext.apply({
                internalRender: this.strict || !Ext.isIE,
                ctCls: 'x-menu-date-item',
                columnWidth: .5
                }, this.initialConfig)
            )
        ];

        this.startDatePicker.on('select',this.startDateSelect, this);
        this.endDatePicker.on('select',this.endDateSelect, this);

        /**
         * The top toolbar.
         * @property tbar
         * @type Ext.Toolbar
         */
        this.tbar= new Ext.Toolbar({
             items: [
             this.startDateButton = new Ext.Button({
                 text: this.tbarStartDateButtonText,
                 cls: 'x-menu-date-range-item-start-date-button',
                 enableToggle: true,
                 allowDepress: false,
                 toggleGroup: 'DateButtonsGroup',
                 toggleHandler: this.onStartDatePress.createDelegate(this)
             }),
             this.rangeDateButton = new Ext.Button({
                 text: this.tbarRangeDateButtonText,
                 cls: 'x-menu-date-range-item-range-date-button',
                 pressed:true,
                 enableToggle: true,
                 allowDepress: false,
                 toggleGroup: 'DateButtonsGroup',
                 toggleHandler: this.onRangeDatePress.createDelegate(this)
             }),'->',
             this.endDateButton = new Ext.Button({
                 text: this.tbarEndDateButtonText,
                 cls: 'x-menu-date-range-item-end-date-button',
                 enableToggle: true,
                 allowDepress: false,
                 toggleGroup: 'DateButtonsGroup',
                 toggleHandler: this.onEndDatePress.createDelegate(this)
             })]
         });

        if(!this.hideValidationButton){
            this.fbar = new Ext.Toolbar({
                cls: 'x-date-bottom',
                items: [{
                    xtype:'button',
                    text:this.fbarOkButtonText,
                    width:'auto',
                    handler:this.onOkButtonPress.createDelegate(this)
                }]
            });
        }

        Genapp.DateRangePicker.superclass.initComponent.call(this);
    },

    // private
    onRangeDatePress: function (button, state){
        if(state){
            this.startDatePicker.enable();
            this.endDatePicker.enable();
            this.resetDates();
        }
    },

    // private
    onStartDatePress: function (button, state){
        if(state){
            this.startDatePicker.enable();
            this.endDatePicker.disable();
            this.resetDates();
        }
    },

    // private
    onEndDatePress: function (button, state){
        if(state){
            this.startDatePicker.disable();
            this.endDatePicker.enable();
            this.resetDates();
        }
    },

    // private
    startDateSelect: function (startDatePicker, date){
        this.selectedDate.startDate = date;
        if(this.startDateButton.pressed){
            this.returnSelectedDate();
        }else{ // rangeDateButton is pressed
            if(this.selectedDate.endDate !== null){
                this.returnSelectedDate();
            }
        }
    },

    // private
    endDateSelect: function (endDatePicker, date){
        this.selectedDate.endDate = date;
        if(this.endDateButton.pressed){
            this.returnSelectedDate();
        }else{ // rangeDateButton is pressed
            if(this.selectedDate.startDate !== null){
                this.returnSelectedDate();
            }
        }
    },

    // private
    resetselectedDate: function(){
        this.selectedDate = {
            startDate:null,
            endDate:null
        };
    },

    /**
     * Reset the dates
     */
    resetDates: function(){
        this.resetselectedDate();
        this.startDatePicker.setValue(this.startDatePicker.defaultValue);
        this.endDatePicker.setValue(this.endDatePicker.defaultValue);
    },

    // private
    returnSelectedDate: function(){
        this.fireEvent('select', this, this.selectedDate);
        this.resetselectedDate();
    },

    /**
     * Checks if the date is in the interval [minDate,maxDate] of the picker
     */
    isEnabledDate: function (picker){
        if((picker.activeDate.getTime() - picker.minDate.getTime() >= 0)
                && (picker.maxDate.getTime() - picker.activeDate.getTime() >= 0)){
            return true;
        } else {
            return false;
        }
    },

    // private
    onOkButtonPress: function (button, state){
        if (state){
            if (this.startDateButton.pressed){
                if (this.isEnabledDate(this.startDatePicker)){
                    this.selectedDate = {
                        startDate:this.startDatePicker.activeDate,
                        endDate:null
                    };
                    this.returnSelectedDate();
                }
            } else if(this.endDateButton.pressed){
                if (this.isEnabledDate(this.endDatePicker)){
                    this.selectedDate = {
                        startDate:null,
                        endDate:this.endDatePicker.activeDate
                    };
                    this.returnSelectedDate();
                }
            } else {
                if (this.isEnabledDate(this.startDatePicker) && this.isEnabledDate(this.endDatePicker)){
                    this.selectedDate = {
                        startDate:this.startDatePicker.activeDate,
                        endDate:this.endDatePicker.activeDate
                    };
                    this.returnSelectedDate();
                }
            }
        }
    }
});


text:
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __TSL_TYPES_H
#define __TSL_TYPES_H

/* Exported types ------------------------------------------------------------*/

/** Generic Boolean status
*/
typedef enum
{
  TSL_FALSE = 0, /**< A False value */
  TSL_TRUE  = 1  /**< A True value */
}
TSL_Bool_enum_T;

/** Generic status returned by functions
*/
typedef enum
{
  TSL_STATUS_OK      = 0, /**< The function has been executed correctly */
  TSL_STATUS_BUSY    = 1, /**< The function is in a Busy state */
  TSL_STATUS_ERROR   = 2  /**< The function has been executed not correctly */
} TSL_Status_enum_T;

/** DataReady status : 1 bit
  - Used by acquisition to indicate if a new measurement is ready or not.
*/
typedef enum
{
  TSL_DATA_NOT_READY = 0, /**< No new measurement or measurement treated */
  TSL_DATA_READY     = 1  /**< A new measurement is ready */
} TSL_DataReady_enum_T;

/** State change status
*/
typedef enum
{
  TSL_STATE_NOT_CHANGED = 0, /**< The object has the same state */
  TSL_STATE_CHANGED     = 1  /**< The object has changed of state */
} TSL_StateChange_enum_T;

#define TSL_ACQ_STATUS_ERROR_MASK (0x02) /**< Associated to TSL_AcqStatus_enum_T */

/** Acquisition status
*/
typedef enum
{
  TSL_ACQ_STATUS_OK        = 0, /**< The acquisition is correct */
  TSL_ACQ_STATUS_NOISE     = 1, /**< Noise detected during the acquisition */
  TSL_ACQ_STATUS_ERROR_MIN = TSL_ACQ_STATUS_ERROR_MASK, /**< The measure is below the minimum threshold */
  TSL_ACQ_STATUS_ERROR_MAX = (TSL_ACQ_STATUS_ERROR_MASK | 0x01) /**< The measure is above the maximum threshold */
} TSL_AcqStatus_enum_T;

/** Bank status
*/
typedef enum
{
  TSL_BANK_STATUS_DISABLED = 0, /**< The bank is disabled */
  TSL_BANK_STATUS_ENABLED  = 1  /**< The bank is enabled */
} TSL_BankStatus_enum_T;

/** Zone status
*/
typedef enum
{
  TSL_ZONE_STATUS_DISABLED = 0, /**< The zone is disabled */
  TSL_ZONE_STATUS_ENABLED  = 1  /**< The zone is enabled */
}TSL_ZoneStatus_enum_T;

#define TSL_OBJ_STATUS_ACQ_MASK   (0x01) /**< Associated to TSL_ObjStatus_enum_T */
#define TSL_OBJ_STATUS_BURST_MASK (0x02) /**< Associated to TSL_ObjStatus_enum_T */

/** Object status
*/
typedef enum
{
  TSL_OBJ_STATUS_OFF        = 0, /**< No burst and no acquisition */
  TSL_OBJ_STATUS_BURST_ONLY = TSL_OBJ_STATUS_BURST_MASK, /**< Burst only */
  TSL_OBJ_STATUS_ON         = (TSL_OBJ_STATUS_BURST_MASK | TSL_OBJ_STATUS_ACQ_MASK) /**< Burst and acquisition */
} TSL_ObjStatus_enum_T;

#define TSL_STATE_ERROR_BIT_MASK    (0x80) /**< Associated to TSL_StateMask_enum_T */
#define TSL_STATE_OFF_BIT_MASK      (0x40) /**< Associated to TSL_StateMask_enum_T */
#define TSL_STATE_DEBOUNCE_BIT_MASK (0x20) /**< Associated to TSL_StateMask_enum_T */
#define TSL_STATE_CALIB_BIT_MASK    (0x10) /**< Associated to TSL_StateMask_enum_T */
#define TSL_STATE_TOUCH_BIT_MASK    (0x08) /**< Associated to TSL_StateMask_enum_T */
#define TSL_STATE_DETECT_BIT_MASK   (0x04) /**< Associated to TSL_StateMask_enum_T */
#define TSL_STATE_PROX_BIT_MASK     (0x02) /**< Associated to TSL_StateMask_enum_T */
#define TSL_STATE_RELEASE_BIT_MASK  (0x01) /**< Associated to TSL_StateMask_enum_T */

/** Object state masks
*/
typedef enum
{
  // Calibration states
  TSL_STATEMASK_CALIB              = TSL_STATE_CALIB_BIT_MASK, /**< 0x10 */
  TSL_STATEMASK_DEB_CALIB          = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_CALIB_BIT_MASK), /**< 0x30 */
  // Release states
  TSL_STATEMASK_RELEASE            = TSL_STATE_RELEASE_BIT_MASK, /**< 0x01 */
  TSL_STATEMASK_DEB_RELEASE_PROX   = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_RELEASE_BIT_MASK | TSL_STATE_PROX_BIT_MASK), /**< 0x23 */
  TSL_STATEMASK_DEB_RELEASE_DETECT = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_RELEASE_BIT_MASK | TSL_STATE_DETECT_BIT_MASK), /**< 0x25 */
  TSL_STATEMASK_DEB_RELEASE_TOUCH  = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_RELEASE_BIT_MASK | TSL_STATE_TOUCH_BIT_MASK), /**< 0x29 */
  // Proximity states
  TSL_STATEMASK_PROX               = TSL_STATE_PROX_BIT_MASK, /**< 0x02 */
  TSL_STATEMASK_DEB_PROX           = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_PROX_BIT_MASK), /**< 0x22 */
  TSL_STATEMASK_DEB_PROX_DETECT    = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_PROX_BIT_MASK | TSL_STATE_DETECT_BIT_MASK), /**< 0x26 */
  TSL_STATEMASK_DEB_PROX_TOUCH     = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_PROX_BIT_MASK | TSL_STATE_TOUCH_BIT_MASK), /**< 0x2A */
  // Detect states
  TSL_STATEMASK_DETECT             = TSL_STATE_DETECT_BIT_MASK, /**< 0x04 */
  TSL_STATEMASK_DEB_DETECT         = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_DETECT_BIT_MASK), /**< 0x24 */
  // Touch state
  TSL_STATEMASK_TOUCH              = TSL_STATE_TOUCH_BIT_MASK, /**< 0x08 */
  // Error states
  TSL_STATEMASK_ERROR              = TSL_STATE_ERROR_BIT_MASK, /**< 0x80 */
  TSL_STATEMASK_DEB_ERROR_CALIB    = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_ERROR_BIT_MASK | TSL_STATE_CALIB_BIT_MASK), /**< 0xB0 */
  TSL_STATEMASK_DEB_ERROR_RELEASE  = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_ERROR_BIT_MASK | TSL_STATE_RELEASE_BIT_MASK), /**< 0xA1 */
  TSL_STATEMASK_DEB_ERROR_PROX     = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_ERROR_BIT_MASK | TSL_STATE_PROX_BIT_MASK), /**< 0xA2 */
  TSL_STATEMASK_DEB_ERROR_DETECT   = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_ERROR_BIT_MASK | TSL_STATE_DETECT_BIT_MASK), /**< 0xA4 */
  TSL_STATEMASK_DEB_ERROR_TOUCH    = (TSL_STATE_DEBOUNCE_BIT_MASK | TSL_STATE_ERROR_BIT_MASK | TSL_STATE_TOUCH_BIT_MASK), /**< 0xA8 */
  // OFF state
  TSL_STATEMASK_OFF                = TSL_STATE_OFF_BIT_MASK, /**< 0x40 */
  // Other states not associated to a state id
  TSL_STATEMASK_ACTIVE             = (TSL_STATE_PROX_BIT_MASK | TSL_STATE_DETECT_BIT_MASK | TSL_STATE_TOUCH_BIT_MASK | TSL_STATE_CALIB_BIT_MASK | TSL_STATE_DEBOUNCE_BIT_MASK), /**< 0x3E */
  TSL_STATEMASK_UNKNOWN            = 0 /**< 0x00 */
} TSL_StateMask_enum_T;

/** Object state identifiers
*/
typedef enum
{
  // Calibration states
  TSL_STATEID_CALIB              = 0,  /**<  0 - Object is in Calibration */
  TSL_STATEID_DEB_CALIB          = 1,  /**<  1 - Object is in Debounce Calibration */
  // Release states
  TSL_STATEID_RELEASE            = 2,  /**<  2 - Object is released */
  TSL_STATEID_DEB_RELEASE_PROX   = 3,  /**<  3 - Object is in Debounce Release from Proximity state */
  TSL_STATEID_DEB_RELEASE_DETECT = 4,  /**<  4 - Object is in Debounce Release from Detect state */
  TSL_STATEID_DEB_RELEASE_TOUCH  = 5,  /**<  5 - Object is in Debounce Release from Touch state */
  // Proximity states
  TSL_STATEID_PROX               = 6,  /**<  6 - Object is in Proximity */
  TSL_STATEID_DEB_PROX           = 7,  /**<  7 - Object is in Debounce Proximity from Release state */
  TSL_STATEID_DEB_PROX_DETECT    = 8,  /**<  8 - Object is in Debounce Proximity from Detect state */
  TSL_STATEID_DEB_PROX_TOUCH     = 9,  /**<  9 - Object is in Debounce Proximity from Detect state */
  // Detect states
  TSL_STATEID_DETECT             = 10, /**< 10 - Object is in Detect */
  TSL_STATEID_DEB_DETECT         = 11, /**< 11 - Object is in Debounce Detect */
  // Touch state
  TSL_STATEID_TOUCH              = 12, /**< 12 - Object is in Touch */
  // Error states
  TSL_STATEID_ERROR              = 13, /**< 13 - Object is in Error */
  TSL_STATEID_DEB_ERROR_CALIB    = 14, /**< 14 - Object is in Debounce Error from Calibration */
  TSL_STATEID_DEB_ERROR_RELEASE  = 15, /**< 15 - Object is in Debounce Error from Release */
  TSL_STATEID_DEB_ERROR_PROX     = 16, /**< 16 - Object is in Debounce Error from Proximity */
  TSL_STATEID_DEB_ERROR_DETECT   = 17, /**< 17 - Object is in Debounce Error from Detect */
  TSL_STATEID_DEB_ERROR_TOUCH    = 18, /**< 18 - Object is in Debounce Error from Touch */
  // Other states
  TSL_STATEID_OFF                = 19  /**< 19 - Object is OFF (no burst, no acquisition) */
} TSL_StateId_enum_T;

/** Object state
*/
typedef struct
{
  TSL_StateMask_enum_T StateMask; /**< Current state mask */
  void(* StateFunc)(void); /**< Function executed in the state */
}
TSL_State_T;

/** Touchkey methods
*/
typedef struct
{
  void(* Init)(void); /**< Used to initialize the TouchKey sensor */
  void(* Process)(void); /**< Used to execute the TouchKey sensor state machine */
}
TSL_TouchKeyMethods_T;

/** Linear/Rotary methods
*/
typedef struct
{
  void(* Init)(void); /**< Used to initialize the Linear/Rotary sensor */
  void(* Process)(void); /**< Used to execute the Linear/Rotary sensor state machine */
  TSL_Status_enum_T(* CalcPosition)(void); /**< Used to calculate the Linear/Rotary sensor position */
}
TSL_LinRotMethods_T;

#endif /* __TSL_TYPES_H */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/


text:
<?xml version="1.0" encoding="UTF-8"?>
<Tokens version="1.0">
	<File path="Classes/DynamoDBUpdateItemRequestMarshaller.html">

		<Token>
			<TokenIdentifier>//apple_ref/occ/cl/DynamoDBUpdateItemRequestMarshaller</TokenIdentifier>
			<Abstract type="html">Update Item Request Marshaller</Abstract>
			<DeclaredIn>DynamoDBUpdateItemRequestMarshaller.h</DeclaredIn>

			<NodeRef refid="332"/>
		</Token>

	</File>
</Tokens>


text:
"Hallo, ich heiße Bernd und bin schiffbrüchig". Die beiden drehen sich schlagartig
in Ihre Richtung und starren Sie mit großen Augen an. Entsetzen ist in
ihr Gesicht geschrieben. Gerade als Sie ...