text:
package com.github.maven_nar.cpptasks.gcc;

import java.io.File;
import java.util.Vector;

import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.types.Environment;

import com.github.maven_nar.cpptasks.CUtil;
import com.github.maven_nar.cpptasks.OptimizationEnum;
import com.github.maven_nar.cpptasks.compiler.LinkType;
import com.github.maven_nar.cpptasks.compiler.Linker;
import com.github.maven_nar.cpptasks.compiler.Processor;
import com.github.maven_nar.cpptasks.parser.CParser;
import com.github.maven_nar.cpptasks.parser.FortranParser;
import com.github.maven_nar.cpptasks.parser.Parser;

/**
 * Adapter for the GCC C/C++ compiler
 *
 * @author Adam Murdoch
 */
public final class GccCCompiler extends GccCompatibleCCompiler {
  private final static String[] sourceExtensions = new String[] {
      ".c", /* C */
      ".cc", /* C++ */
      ".cpp", /* C++ */
      ".cxx", /* C++ */
      ".c++", /* C++ */
      ".i", /* preprocessed C */
      ".ii", /* preprocessed C++ */
      ".f", /* FORTRAN */
      ".for", /* FORTRAN */
      ".f90", /* FORTRAN 90 */
      ".m", /* Objective-C */
      ".mm", /* Objected-C++ */
      ".s" /* Assembly */
  };
  private final static String[] headerExtensions = new String[] {
      ".h", ".hpp", ".inl"
  };
  private static final GccCCompiler cppInstance = new GccCCompiler("c++", sourceExtensions, headerExtensions, false,
      new GccCCompiler("c++", sourceExtensions, headerExtensions, true, null, false, null), false, null);
  private static final GccCCompiler g77Instance = new GccCCompiler("g77", sourceExtensions, headerExtensions, false,
      new GccCCompiler("g77", sourceExtensions, headerExtensions, true, null, false, null), false, null);
  // FREEHEP
  private static final GccCCompiler gfortranInstance = new GccCCompiler("gfortran", sourceExtensions, headerExtensions,
      false, new GccCCompiler("gfortran", sourceExtensions, headerExtensions, true, null, false, null), false, null);
  private static final GccCCompiler gppInstance = new GccCCompiler("g++", sourceExtensions, headerExtensions, false,
      new GccCCompiler("g++", sourceExtensions, headerExtensions, true, null, false, null), false, null);
  private static final GccCCompiler instance = new GccCCompiler("gcc", sourceExtensions, headerExtensions, false,
      new GccCCompiler("gcc", sourceExtensions, headerExtensions, true, null, false, null), false, null);
  private static final GccCCompiler clangInstance = new GccCCompiler("clang", sourceExtensions, headerExtensions,
      false, new GccCCompiler("clang", sourceExtensions, headerExtensions, true, null, false, null), false, null);
  private static final GccCCompiler cpplangInstance = new GccCCompiler("clang++", sourceExtensions, headerExtensions,
      false, new GccCCompiler("clang++", sourceExtensions, headerExtensions, true, null, false, null), false, null);

  /**
   * Gets clang adapter
   */
  public static GccCCompiler getCLangInstance() {
    return clangInstance;
  }

  /**
   * Gets clang++ adapter
   */
  public static GccCCompiler getCLangppInstance() {
    return cpplangInstance;
  }

  /**
   * Gets c++ adapter
   */
  public static GccCCompiler getCppInstance() {
    return cppInstance;
  }

  /**
   * Gets g77 adapter
   */
  public static GccCCompiler getG77Instance() {
    return g77Instance;
  }

  /**
   * Gets g77 adapter
   */
  // FREEHEPBEGIN
  public static GccCCompiler getGFortranInstance() {
    return gfortranInstance;
  }

  // FREEHEPEND
  /**
   * Gets gpp adapter
   */
  public static GccCCompiler getGppInstance() {
    return gppInstance;
  }

  /**
   * Gets gcc adapter
   */
  public static GccCCompiler getInstance() {
    return instance;
  }

  private String identifier;
  private File[] includePath;
  private boolean isPICMeaningful = true;

  /**
   * Private constructor. Use GccCCompiler.getInstance() to get singleton
   * instance of this class.
   */
  private GccCCompiler(final String command, final String[] sourceExtensions, final String[] headerExtensions,
      final boolean isLibtool, final GccCCompiler libtoolCompiler, final boolean newEnvironment, final Environment env) {
    super(command, null, sourceExtensions, headerExtensions, isLibtool, libtoolCompiler, newEnvironment, env);
    this.isPICMeaningful = !System.getProperty("os.name").contains("Windows");
  }

  @Override
  public void addImpliedArgs(final Vector args, final boolean debug, final boolean multithreaded,
      final boolean exceptions, final LinkType linkType, final Boolean rtti, final OptimizationEnum optimization) {
    super.addImpliedArgs(args, debug, multithreaded, exceptions, linkType, rtti, optimization);
    if (this.isPICMeaningful && linkType.isSharedLibrary()) {
      args.addElement("-fPIC");
    }
    // BEGINFREEHEP
    // Add -fno_rtti only for g++ and c++
    if (!getCommand().equals("g77") && !getCommand().equals("gcc") && rtti != null && !rtti.booleanValue()) {
      // Darren Sargent: fix RTTI option
      args.addElement("-fno-rtti");
    }
    // ENDFREEHEP
  }

  @Override
  public Processor changeEnvironment(final boolean newEnvironment, final Environment env) {
    if (newEnvironment || env != null) {
      return new GccCCompiler(getCommand(), this.getSourceExtensions(), this.getHeaderExtensions(), this.getLibtool(),
          (GccCCompiler) this.getLibtoolCompiler(), newEnvironment, env);
    }
    return this;
  }

  /**
   * Create parser to determine dependencies.
   *
   * Will create appropriate parser (C++, FORTRAN) based on file extension.
   *
   */
  @Override
  protected Parser createParser(final File source) {
    if (source != null) {
      final String sourceName = source.getName();
      final int lastDot = sourceName.lastIndexOf('.');
      if (lastDot >= 0 && lastDot + 1 < sourceName.length()) {
        final char afterDot = sourceName.charAt(lastDot + 1);
        if (afterDot == 'f' || afterDot == 'F') {
          return new FortranParser();
        }
      }
    }
    return new CParser();
  }

  @Override
  public File[] getEnvironmentIncludePath() {
    if (this.includePath == null) {
      //
      // construct default include path from machine id and version id
      //
      final String[] defaultInclude = new String[1];
      final String buf = "/lib/" + GccProcessor.getMachine() +
          '/' +
          GccProcessor.getVersion() +
          "/include";
      defaultInclude[0] = buf;
      //
      // read specs file and look for -istart and -idirafter
      //
      final String[] specs = GccProcessor.getSpecs();
      final String[][] optionValues = GccProcessor.parseSpecs(specs, "*cpp:", new String[] {
          "-isystem ", "-idirafter "
      });
      //
      // if no entries were found, then use a default path
      //
      if (optionValues[0].length == 0 && optionValues[1].length == 0) {
        optionValues[0] = new String[] {
            "/usr/local/include", "/usr/include", "/usr/include/win32api"
        };
      }
      //
      // remove mingw entries.
      // For MinGW compiles this will mean the
      // location of the sys includes will be
      // wrong in dependencies.xml
      // but that should have no significant effect
      for (int i = 0; i < optionValues.length; i++) {
        for (int j = 0; j < optionValues[i].length; j++) {
          if (optionValues[i][j].indexOf("mingw") > 0) {
            optionValues[i][j] = null;
          }
        }
      }
      //
      // if cygwin then
      // we have to prepend location of gcc32
      // and .. to start of absolute filenames to
      // have something that will exist in the
      // windows filesystem
      if (GccProcessor.isCygwin()) {
        GccProcessor.convertCygwinFilenames(optionValues[0]);
        GccProcessor.convertCygwinFilenames(optionValues[1]);
        GccProcessor.convertCygwinFilenames(defaultInclude);
      }
      int count = CUtil.checkDirectoryArray(optionValues[0]);
      count += CUtil.checkDirectoryArray(optionValues[1]);
      count += CUtil.checkDirectoryArray(defaultInclude);
      this.includePath = new File[count];
      int index = 0;
      for (final String[] optionValue : optionValues) {
        for (final String anOptionValue : optionValue) {
          if (anOptionValue != null) {
            this.includePath[index++] = new File(anOptionValue);
          }
        }
      }
      for (final String element : defaultInclude) {
        if (element != null) {
          this.includePath[index++] = new File(element);
        }
      }
    }
    return this.includePath.clone();
  }

  @Override
  public String getIdentifier() throws BuildException {
    if (this.identifier == null) {
      StringBuffer buf;
      if (getLibtool()) {
        buf = new StringBuffer("libtool ");
      } else {
        buf = new StringBuffer(" ");
      }
      buf.append(getCommand());
      buf.append(' ');
      buf.append(GccProcessor.getVersion());
      buf.append(' ');
      buf.append(GccProcessor.getMachine());
      this.identifier = buf.toString();
    }
    return this.identifier;
  }

  @Override
  public Linker getLinker(final LinkType linkType) {
    return GccLinker.getInstance().getLinker(linkType);
  }

  // BEGINFREEHEP
  @Override
  public int getMaximumCommandLength() {
    return isWindows() ? 20000 : Integer.MAX_VALUE;
  }
  // ENDFREEHEP
}


text:
<web-app xmlns="http://java.sun.com/xml/ns/javaee" version="2.5">
    <listener>
        <listener-class>groovyx.gaelyk.GaelykServletContextListener</listener-class>
    </listener>

    <servlet>
        <servlet-name>GroovletServlet</servlet-name>
        <servlet-class>groovyx.gaelyk.GaelykServlet</servlet-class>
        <init-param>
            <param-name>verbose</param-name>
            <!-- Set it to true for more details -->
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet>
        <servlet-name>TemplateServlet</servlet-name>
        <servlet-class>groovyx.gaelyk.GaelykTemplateServlet</servlet-class>
        <init-param>
            <!-- Remove the default "generated by" messages from the templates -->
            <param-name>generated.by</param-name>
            <param-value>false</param-value>
        </init-param>
        <init-param>
            <param-name>verbose</param-name>
            <!-- Output generation time in the HTML, see source page -->
            <param-value>false</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>

    <filter>
        <filter-name>RoutesFilter</filter-name>
        <filter-class>groovyx.gaelyk.routes.RoutesFilter</filter-class>
    </filter>

    <servlet-mapping>
        <servlet-name>GroovletServlet</servlet-name>
        <url-pattern>*.groovy</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>TemplateServlet</servlet-name>
        <url-pattern>*.gtpl</url-pattern>
    </servlet-mapping>

    <filter-mapping>
        <filter-name>RoutesFilter</filter-name>
        <url-pattern>/*</url-pattern>
        <dispatcher>INCLUDE</dispatcher>
        <dispatcher>FORWARD</dispatcher>
        <dispatcher>REQUEST</dispatcher>
        <dispatcher>ERROR</dispatcher>
    </filter-mapping>

    <!-- Uncomment the following security constraint if you want to secure your incoming email endpoint -->
    <!-- Only allow the SDK and administrators to have access to the incoming email endpoint -->
    <!--
    <security-constraint>
        <web-resource-collection>
            <url-pattern>/_ah/mail/*</url-pattern>
            <url-pattern>/_ah/xmpp/message/chat/</url-pattern>
        </web-resource-collection>
        <auth-constraint>
            <role-name>admin</role-name>
        </auth-constraint>
    </security-constraint>
    -->

    <welcome-file-list>
        <welcome-file>index.gtpl</welcome-file>
    </welcome-file-list>
</web-app>

redpajama_set_name: RedPajamaGithub


text:
@echo off

REM Restore NuGet packages
.nuget\nuget.exe restore Open-XML-SDK.sln

REM Build release
set FrameworkVersion=v4.0.30319
set FrameworkDir=%SystemRoot%\Microsoft.NET\Framework

if exist "%SystemRoot%\Microsoft.NET\Framework64" (
  set FrameworkDir=%SystemRoot%\Microsoft.NET\Framework64
)

"%FrameworkDir%\%FrameworkVersion%\msbuild.exe" /p:Configuration=Release Open-XML-SDK.sln

REM Run tests
packages\xunit.runner.console.2.0.0\tools\xunit.console.exe System.IO.Packaging.Tests\bin\Release\System.IO.Packaging.Tests.dll
packages\xunit.runner.console.2.0.0\tools\xunit.console.exe DocumentFormat.OpenXml.Tests\bin\Release\DocumentFormat.OpenXml.Tests.dll


text:
import { NgModule } from '@angular/core';
import { BrowserModule } from '@angular/platform-browser';
import { ChartModule, HIGHCHARTS_MODULES } from 'angular-highcharts';
import more from 'highcharts/highcharts-more.src';
import exporting from 'highcharts/modules/exporting.src';

import { AppComponent } from './app.component';

@NgModule({
  declarations: [AppComponent],
  imports: [BrowserModule, ChartModule],
  providers: [{ provide: HIGHCHARTS_MODULES, useFactory: () => [more, exporting] }],
  bootstrap: [AppComponent]
})
export class AppModule {}


text:
using System;

namespace SharpYaml.Tokens
{
	/// <summary>
	/// Represents a block sequence start token.
	/// </summary>
	public class BlockSequenceStart : Token
	{
		/// <summary>
		/// Initializes a new instance of the <see cref="BlockSequenceStart"/> class.
		/// </summary>
		public BlockSequenceStart()
			: this(Mark.Empty, Mark.Empty)
		{
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="BlockSequenceStart"/> class.
		/// </summary>
		/// <param name="start">The start position of the token.</param>
		/// <param name="end">The end position of the token.</param>
		public BlockSequenceStart(Mark start, Mark end)
			: base(start, end)
		{
		}
	}
}


text:
package com.evolveum.midpoint.prism.impl.item;

import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.function.Consumer;
import java.util.function.Function;

import javax.xml.namespace.QName;

import com.evolveum.midpoint.prism.CloneStrategy;
import com.evolveum.midpoint.prism.ConsistencyCheckScope;
import com.evolveum.midpoint.prism.Item;
import com.evolveum.midpoint.prism.ItemDefinition;
import com.evolveum.midpoint.prism.Itemable;
import com.evolveum.midpoint.prism.PartiallyResolvedItem;
import com.evolveum.midpoint.prism.PrismContainerValue;
import com.evolveum.midpoint.prism.PrismContext;
import com.evolveum.midpoint.prism.PrismReference;
import com.evolveum.midpoint.prism.PrismReferenceDefinition;
import com.evolveum.midpoint.prism.PrismReferenceValue;
import com.evolveum.midpoint.prism.PrismValue;
import com.evolveum.midpoint.prism.Referencable;
import com.evolveum.midpoint.prism.Visitor;
import com.evolveum.midpoint.prism.delta.ItemDelta;
import com.evolveum.midpoint.prism.delta.ReferenceDelta;
import com.evolveum.midpoint.prism.equivalence.EquivalenceStrategy;
import com.evolveum.midpoint.prism.equivalence.ParameterizedEquivalenceStrategy;
import com.evolveum.midpoint.prism.path.ItemName;
import com.evolveum.midpoint.prism.path.ItemPath;
import com.evolveum.midpoint.prism.polystring.PolyString;
import com.evolveum.midpoint.util.exception.SchemaException;
import org.jetbrains.annotations.NotNull;

/**
 * @author semancik
 *
 */
public class DummyReferenceImpl implements PrismReference {

    private final PrismReference realReference;
    @NotNull private final ItemPath path;

    public DummyReferenceImpl(PrismReference realReference, @NotNull ItemPath path) {
        super();
        this.realReference = realReference;
        this.path = path;
    }

    public void accept(Visitor visitor) {
        realReference.accept(visitor);
    }

    public void accept(Visitor visitor, ItemPath path, boolean recursive) {
        realReference.accept(visitor, path, recursive);
    }

    public Referencable getRealValue() {
        return realReference.getRealValue();
    }

    @NotNull
    public Collection<Referencable> getRealValues() {
        return realReference.getRealValues();
    }

    public boolean merge(PrismReferenceValue value) {
        return realReference.merge(value);
    }

    public String getOid() {
        return realReference.getOid();
    }

    public PolyString getTargetName() {
        return realReference.getTargetName();
    }

    public PrismReferenceDefinition getDefinition() {
        return realReference.getDefinition();
    }

    public PrismReferenceValue findValueByOid(String oid) {
        return realReference.findValueByOid(oid);
    }

    public Object find(ItemPath path) {
        return realReference.find(path);
    }

    public <IV extends PrismValue, ID extends ItemDefinition> PartiallyResolvedItem<IV, ID> findPartial(
            ItemPath path) {
        return realReference.findPartial(path);
    }

    public boolean hasCompleteDefinition() {
        return realReference.hasCompleteDefinition();
    }

    public ReferenceDelta createDelta() {
        return realReference.createDelta();
    }

    public ReferenceDelta createDelta(ItemPath path) {
        return realReference.createDelta(path);
    }

    public PrismReference clone() {
        return realReference.clone();
    }

    public ItemName getElementName() {
        return realReference.getElementName();
    }

    public PrismReference cloneComplex(CloneStrategy strategy) {
        return realReference.cloneComplex(strategy);
    }

    public String toString() {
        return "Dummy" + realReference.toString();
    }

    public String debugDump(int indent) {
        return realReference.debugDump(indent);
    }

    public void setElementName(QName elementName) {
        realReference.setElementName(elementName);
    }

    public void setDefinition(PrismReferenceDefinition definition) {
        realReference.setDefinition(definition);
    }

    public String getDisplayName() {
        return realReference.getDisplayName();
    }

    public String getHelp() {
        return realReference.getHelp();
    }

    public boolean isIncomplete() {
        return realReference.isIncomplete();
    }

    public void setIncomplete(boolean incomplete) {
        realReference.setIncomplete(incomplete);
    }

    public PrismContainerValue<?> getParent() {
        throw new UnsupportedOperationException();
    }

    public void setParent(PrismContainerValue<?> parentValue) {
        throw new UnsupportedOperationException();
    }

    @NotNull
    public ItemPath getPath() {
        return path;
    }

    @NotNull
    public Map<String, Object> getUserData() {
        return realReference.getUserData();
    }

    public <T> T getUserData(String key) {
        return realReference.getUserData(key);
    }

    public void setUserData(String key, Object value) {
        realReference.setUserData(key, value);
    }

    @NotNull
    public List<PrismReferenceValue> getValues() {
        return realReference.getValues();
    }

    public int size() {
        return realReference.size();
    }

    public PrismReferenceValue getAnyValue() {
        return realReference.getAnyValue();
    }

    public PrismReferenceValue getValue() {
        return realReference.getValue();
    }

    public boolean isSingleValue() {
        return realReference.isSingleValue();
    }

    public boolean add(@NotNull PrismReferenceValue newValue, boolean checkUniqueness) throws SchemaException {
        return realReference.add(newValue, checkUniqueness);
    }

    public boolean add(@NotNull PrismReferenceValue newValue) throws SchemaException {
        return realReference.add(newValue);
    }

    public boolean add(@NotNull PrismReferenceValue newValue, @NotNull EquivalenceStrategy equivalenceStrategy)
            throws SchemaException {
        return realReference.add(newValue, equivalenceStrategy);
    }

    public boolean addAll(Collection<PrismReferenceValue> newValues) throws SchemaException {
        return realReference.addAll(newValues);
    }

    public boolean addAll(Collection<PrismReferenceValue> newValues, EquivalenceStrategy strategy)
            throws SchemaException {
        return realReference.addAll(newValues, strategy);
    }

    @Override
    public boolean addAll(Collection<PrismReferenceValue> newValues, boolean checkUniqueness, EquivalenceStrategy strategy)
            throws SchemaException {
        return realReference.addAll(newValues, checkUniqueness, strategy);
    }

    public boolean remove(PrismReferenceValue value) {
        return realReference.remove(value);
    }

    public boolean remove(PrismReferenceValue value, @NotNull EquivalenceStrategy strategy) {
        return realReference.remove(value, strategy);
    }

    public boolean removeAll(Collection<PrismReferenceValue> values) {
        return realReference.removeAll(values);
    }

    public void clear() {
        realReference.clear();
    }

    public void replaceAll(Collection<PrismReferenceValue> newValues, EquivalenceStrategy strategy)
            throws SchemaException {
        realReference.replaceAll(newValues, strategy);
    }

    public void replace(PrismReferenceValue newValue) throws SchemaException {
        realReference.replace(newValue);
    }

    public boolean equals(Object obj) {
        return realReference.equals(obj);
    }

    public boolean equals(Object obj, @NotNull EquivalenceStrategy equivalenceStrategy) {
        return realReference.equals(obj, equivalenceStrategy);
    }

    public boolean equals(Object obj, @NotNull ParameterizedEquivalenceStrategy equivalenceStrategy) {
        return realReference.equals(obj, equivalenceStrategy);
    }

    public int hashCode() {
        return realReference.hashCode();
    }

    public int hashCode(@NotNull EquivalenceStrategy equivalenceStrategy) {
        return realReference.hashCode(equivalenceStrategy);
    }

    public int hashCode(@NotNull ParameterizedEquivalenceStrategy equivalenceStrategy) {
        return realReference.hashCode(equivalenceStrategy);
    }

    public boolean contains(PrismReferenceValue value) {
        return realReference.contains(value);
    }

    public boolean contains(PrismReferenceValue value, @NotNull EquivalenceStrategy strategy) {
        return realReference.contains(value, strategy);
    }

    public boolean contains(PrismReferenceValue value, EquivalenceStrategy strategy,
            Comparator<PrismReferenceValue> comparator) {
        return realReference.contains(value, strategy, comparator);
    }

    public boolean containsEquivalentValue(PrismReferenceValue value) {
        return realReference.containsEquivalentValue(value);
    }

    public boolean containsEquivalentValue(PrismReferenceValue value,
            Comparator<PrismReferenceValue> comparator) {
        return realReference.containsEquivalentValue(value, comparator);
    }

    public PrismReferenceValue findValue(PrismReferenceValue value, @NotNull EquivalenceStrategy strategy) {
        return realReference.findValue(value, strategy);
    }

    public boolean valuesEqual(Collection<PrismReferenceValue> matchValues,
            Comparator<PrismReferenceValue> comparator) {
        return realReference.valuesEqual(matchValues, comparator);
    }

    public ItemDelta<PrismReferenceValue, PrismReferenceDefinition> diff(
            Item<PrismReferenceValue, PrismReferenceDefinition> other) {
        return realReference.diff(other);
    }

    public ItemDelta<PrismReferenceValue, PrismReferenceDefinition> diff(
            Item<PrismReferenceValue, PrismReferenceDefinition> other,
            @NotNull ParameterizedEquivalenceStrategy strategy) {
        return realReference.diff(other, strategy);
    }

    public Collection<PrismReferenceValue> getClonedValues() {
        return realReference.getClonedValues();
    }

    public void normalize() {
        realReference.normalize();
    }

    public void merge(Item<PrismReferenceValue, PrismReferenceDefinition> otherItem) throws SchemaException {
        realReference.merge(otherItem);
    }

    public void acceptParentVisitor(@NotNull Visitor visitor) {
        realReference.acceptParentVisitor(visitor);
    }

    public void recomputeAllValues() {
        realReference.recomputeAllValues();
    }

    public void filterValues(Function<PrismReferenceValue, Boolean> function) {
        realReference.filterValues(function);
    }

    public void applyDefinition(PrismReferenceDefinition definition) throws SchemaException {
        realReference.applyDefinition(definition);
    }

    public void applyDefinition(PrismReferenceDefinition definition, boolean force) throws SchemaException {
        realReference.applyDefinition(definition, force);
    }

    public void revive(PrismContext prismContext) throws SchemaException {
        realReference.revive(prismContext);
    }

    public void checkConsistence(boolean requireDefinitions, ConsistencyCheckScope scope) {
        realReference.checkConsistence(requireDefinitions, scope);
    }

    public void checkConsistence(boolean requireDefinitions, boolean prohibitRaw) {
        realReference.checkConsistence(requireDefinitions, prohibitRaw);
    }

    public void checkConsistence(boolean requireDefinitions, boolean prohibitRaw,
            ConsistencyCheckScope scope) {
        realReference.checkConsistence(requireDefinitions, prohibitRaw, scope);
    }

    public void checkConsistence() {
        realReference.checkConsistence();
    }

    public void checkConsistence(ConsistencyCheckScope scope) {
        realReference.checkConsistence(scope);
    }

    public void checkConsistenceInternal(Itemable rootItem, boolean requireDefinitions, boolean prohibitRaw,
            ConsistencyCheckScope scope) {
        realReference.checkConsistenceInternal(rootItem, requireDefinitions, prohibitRaw, scope);
    }

    public void assertDefinitions() throws SchemaException {
        realReference.assertDefinitions();
    }

    public void assertDefinitions(String sourceDescription) throws SchemaException {
        realReference.assertDefinitions(sourceDescription);
    }

    public void assertDefinitions(boolean tolerateRawValues, String sourceDescription)
            throws SchemaException {
        realReference.assertDefinitions(tolerateRawValues, sourceDescription);
    }

    public boolean isRaw() {
        return realReference.isRaw();
    }

    public boolean hasRaw() {
        return realReference.hasRaw();
    }

    public boolean isEmpty() {
        return realReference.isEmpty();
    }

    public boolean hasNoValues() {
        return realReference.hasNoValues();
    }

    public boolean isOperational() {
        return realReference.isOperational();
    }

    public boolean isImmutable() {
        return realReference.isImmutable();
    }

    public void setImmutable(boolean immutable) {
        realReference.setImmutable(immutable);
    }

    public void checkImmutability() {
        realReference.checkImmutability();
    }

    public void modifyUnfrozen(Runnable mutator) {
        realReference.modifyUnfrozen(mutator);
    }

    public void modifyUnfrozen(Consumer<Item<PrismReferenceValue, PrismReferenceDefinition>> mutator) {
        realReference.modifyUnfrozen(mutator);
    }

    @NotNull
    public Collection<PrismValue> getAllValues(ItemPath path) {
        return realReference.getAllValues(path);
    }

    public PrismContext getPrismContext() {
        return realReference.getPrismContext();
    }

    public PrismContext getPrismContextLocal() {
        return realReference.getPrismContextLocal();
    }

    public void setPrismContext(PrismContext prismContext) {
        realReference.setPrismContext(prismContext);
    }

    public Long getHighestId() {
        return realReference.getHighestId();
    }

}


text:
Capybara::SpecHelper.spec '#has_xpath?' do
  before do
    @session.visit('/with_html')
  end

  it 'should be true if the given selector is on the page' do
    expect(@session).to have_xpath('//p')
    expect(@session).to have_xpath("//p//a[@id='foo']")
    expect(@session).to have_xpath("//p[contains(.,'est')]")
  end

  it 'should support :id option' do
    expect(@session).to have_xpath('//h2', id: 'h2one')
    expect(@session).to have_xpath('//h2')
    expect(@session).to have_xpath('//h2', id: /h2o/)
  end

  it 'should support :class option' do
    expect(@session).to have_xpath('//li', class: 'guitarist')
    expect(@session).to have_xpath('//li', class: /guitar/)
    expect(@session).to have_xpath('//li', class: /guitar|drummer/)
    expect(@session).to have_xpath('//li', class: %w[beatle guitarist])
    expect(@session).to have_xpath('//li', class: /.*/)
  end

  it 'should be false if the given selector is not on the page' do
    expect(@session).not_to have_xpath('//abbr')
    expect(@session).not_to have_xpath("//p//a[@id='doesnotexist']")
    expect(@session).not_to have_xpath("//p[contains(.,'thisstringisnotonpage')]")
  end

  it 'should use xpath even if default selector is CSS' do
    Capybara.default_selector = :css
    expect(@session).not_to have_xpath("//p//a[@id='doesnotexist']")
  end

  it 'should respect scopes' do
    @session.within "//p[@id='first']" do
      expect(@session).to have_xpath(".//a[@id='foo']")
      expect(@session).not_to have_xpath(".//a[@id='red']")
    end
  end

  it 'should wait for content to appear', requires: [:js] do
    Capybara.using_wait_time(3) do
      @session.visit('/with_js')
      @session.click_link('Click me') # updates page after 500ms
      expect(@session).to have_xpath("//input[@type='submit' and @value='New Here']")
    end
  end

  context 'with count' do
    it 'should be true if the content occurs the given number of times' do
      expect(@session).to have_xpath('//p', count: 3)
      expect(@session).to have_xpath("//p//a[@id='foo']", count: 1)
      expect(@session).to have_xpath("//p[contains(.,'est')]", count: 1)
      expect(@session).to have_xpath("//p//a[@id='doesnotexist']", count: 0)
      expect(@session).to have_xpath('//li', class: /guitar|drummer/, count: 4)
      expect(@session).to have_xpath('//li', id: /john|paul/, class: /guitar|drummer/, count: 2)
      expect(@session).to have_xpath('//li', class: %w[beatle guitarist], count: 2)
    end

    it 'should be false if the content occurs a different number of times than the given' do
      expect(@session).not_to have_xpath('//p', count: 6)
      expect(@session).not_to have_xpath("//p//a[@id='foo']", count: 2)
      expect(@session).not_to have_xpath("//p[contains(.,'est')]", count: 5)
      expect(@session).not_to have_xpath("//p//a[@id='doesnotexist']", count: 1)
    end
  end

  context 'with text' do
    it 'should discard all matches where the given string is not contained' do
      expect(@session).to have_xpath('//p//a', text: 'Redirect', count: 1)
      expect(@session).not_to have_xpath('//p', text: 'Doesnotexist')
    end

    it 'should discard all matches where the given regexp is not matched' do
      expect(@session).to have_xpath('//p//a', text: /re[dab]i/i, count: 1)
      expect(@session).not_to have_xpath('//p//a', text: /Red$/)
    end
  end
end

Capybara::SpecHelper.spec '#has_no_xpath?' do
  before do
    @session.visit('/with_html')
  end

  it 'should be false if the given selector is on the page' do
    expect(@session).not_to have_no_xpath('//p')
    expect(@session).not_to have_no_xpath("//p//a[@id='foo']")
    expect(@session).not_to have_no_xpath("//p[contains(.,'est')]")
  end

  it 'should be true if the given selector is not on the page' do
    expect(@session).to have_no_xpath('//abbr')
    expect(@session).to have_no_xpath("//p//a[@id='doesnotexist']")
    expect(@session).to have_no_xpath("//p[contains(.,'thisstringisnotonpage')]")
  end

  it 'should use xpath even if default selector is CSS' do
    Capybara.default_selector = :css
    expect(@session).to have_no_xpath("//p//a[@id='doesnotexist']")
  end

  it 'should respect scopes' do
    @session.within "//p[@id='first']" do
      expect(@session).not_to have_no_xpath(".//a[@id='foo']")
      expect(@session).to have_no_xpath(".//a[@id='red']")
    end
  end

  it 'should wait for content to disappear', requires: [:js] do
    Capybara.default_max_wait_time = 2
    @session.visit('/with_js')
    @session.click_link('Click me')
    expect(@session).to have_no_xpath("//p[@id='change']")
  end

  context 'with count' do
    it 'should be false if the content occurs the given number of times' do
      expect(@session).not_to have_no_xpath('//p', count: 3)
      expect(@session).not_to have_no_xpath("//p//a[@id='foo']", count: 1)
      expect(@session).not_to have_no_xpath("//p[contains(.,'est')]", count: 1)
      expect(@session).not_to have_no_xpath("//p//a[@id='doesnotexist']", count: 0)
    end

    it 'should be true if the content occurs a different number of times than the given' do
      expect(@session).to have_no_xpath('//p', count: 6)
      expect(@session).to have_no_xpath("//p//a[@id='foo']", count: 2)
      expect(@session).to have_no_xpath("//p[contains(.,'est')]", count: 5)
      expect(@session).to have_no_xpath("//p//a[@id='doesnotexist']", count: 1)
    end
  end

  context 'with text' do
    it 'should discard all matches where the given string is contained' do
      expect(@session).not_to have_no_xpath('//p//a', text: 'Redirect', count: 1)
      expect(@session).to have_no_xpath('//p', text: 'Doesnotexist')
    end

    it 'should discard all matches where the given regexp is matched' do
      expect(@session).not_to have_no_xpath('//p//a', text: /re[dab]i/i, count: 1)
      expect(@session).to have_no_xpath('//p//a', text: /Red$/)
    end
  end
end


text:
<?xml version="1.0" encoding="UTF-8"?>
<!--

  Copyright (C) Christian Schulte, 2005-206
  All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:

    o Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.

    o Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in
      the documentation and/or other materials provided with the
      distribution.

  THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
  THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY DIRECT, INDIRECT,
  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

  $JOMC$

-->
<module xmlns="http://jomc.org/model"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="http://jomc.org/model http://jomc.sourceforge.net/model/jomc-1.2.xsd"
        name="${project.name} Client"
        version="${project.version}"
        vendor="${project.organization.name}"
        modelVersion="1.2">

  <documentation defaultLanguage="en">
    <text language="en">${project.description}</text>
  </documentation>
  <implementations>
    <!-- *********************************************************************************************************** -->
    <implementation identifier="org.jomc.sequences.SequenceOperations"
                    name="org.jomc.sequences.SequenceOperations"
                    location="jndi+rmi:jomc-sequences-ear-${project.version}/org.jomc.sequences.ri.DefaultSequenceDirectory/remote-org.jomc.sequences.SequenceOperations"
                    vendor="${project.organization.name}"
                    version="${project.version}"
                    final="true">

      <documentation defaultLanguage="en">
        <text language="en">SequenceOperations client.</text>
      </documentation>
      <authors>
        <author name="Christian Schulte" version="1.0" mail="schulte2005@users.sourceforge.net" createDate="2005-07-25T19:56:45Z"/>
      </authors>
      <specifications>
        <reference identifier="org.jomc.sequences.SequenceOperations" version="1.0"/>
      </specifications>
    </implementation>
    <!-- *********************************************************************************************************** -->
    <implementation identifier="org.jomc.sequences.SequenceDirectory"
                    name="org.jomc.sequences.SequenceDirectory"
                    location="jndi+rmi:jomc-sequences-ear-${project.version}/org.jomc.sequences.ri.DefaultSequenceDirectory/remote-org.jomc.sequences.SequenceDirectory"
                    vendor="${project.organization.name}"
                    version="${project.version}"
                    final="true">

      <documentation defaultLanguage="en">
        <text language="en">SequenceDirectory client.</text>
      </documentation>
      <authors>
        <author name="Christian Schulte" version="1.0" mail="schulte2005@users.sourceforge.net" createDate="2005-07-25T19:56:45Z"/>
      </authors>
      <specifications>
        <reference identifier="org.jomc.sequences.SequenceDirectory" version="1.0"/>
      </specifications>
    </implementation>
  </implementations>
</module>


text:
package org.zalando.nakadi.client.java.model;

import org.zalando.nakadi.client.java.model.BusinessEvent;
import org.zalando.nakadi.client.java.model.EventMetadata;

import com.fasterxml.jackson.annotation.JsonCreator;
import com.fasterxml.jackson.annotation.JsonProperty;

public class BusinessEventImpl   implements BusinessEvent {
    private EventMetadata metadata;

    @JsonCreator
    public BusinessEventImpl(  @JsonProperty("metadata")EventMetadata metadata) {
        this.metadata = metadata;
    }

    public EventMetadata metadata() {
        return metadata;
    }
    public EventMetadata getMetadata() {
        return metadata;
    }

    @Override
    public String toString() {
        return "BusinessEventImpl [eventMetdata=" + metadata + "]";
    }

}


text:
layout: page
title: Sanford Motors Conference
date: 2016-05-24
author: Peter Mckenzie
tags: weekly links, java
status: published
summary: Donec ultricies varius nisl, id auctor.
banner: images/banner/leisure-03.jpg
booking:
  startDate: 11/12/2017
  endDate: 11/13/2017
  ctyhocn: PNSAPHX
  groupCode: SMC
published: true
---
Donec finibus lacinia diam a condimentum. Sed consectetur pulvinar odio et rutrum. Nulla volutpat rhoncus nibh sit amet pellentesque. Integer eros lorem, euismod id congue sit amet, interdum nec magna. Donec venenatis eleifend est, ut ullamcorper nisi placerat a. Sed laoreet lectus eu arcu venenatis efficitur. Curabitur faucibus nec diam ut rhoncus. Pellentesque varius tristique felis scelerisque elementum. Duis orci orci, commodo a neque sit amet, sollicitudin condimentum nibh.
Quisque in elementum est. Etiam non sagittis ex. Sed iaculis id nisi ultricies dapibus. Morbi tempor vitae ante id fringilla. Curabitur vestibulum dui sit amet nunc tempus aliquam. Vestibulum blandit mauris et purus ultrices, at dapibus sapien consequat. Ut non elementum ex. Fusce quis velit semper, porta ex quis, commodo justo. Donec vitae nisl enim. Nunc ac luctus nunc. Mauris porttitor nunc et lectus tristique egestas vel nec lectus.

* Nam bibendum arcu et enim accumsan tristique
* Suspendisse ultrices nunc non est aliquet, a rutrum risus finibus
* Donec sit amet mi vitae dolor pellentesque ultrices suscipit et nisi
* Etiam ultrices libero ac eros laoreet imperdiet vel vehicula ante
* Integer vitae justo in nisi tincidunt pellentesque ac non mi
* Integer aliquam est sit amet fermentum fermentum.

Aliquam erat volutpat. Duis auctor nec erat ut iaculis. Nunc ac quam sed magna semper bibendum. Etiam et augue in libero porta egestas quis sed diam. In ut ante sit amet libero sodales egestas et id nulla. Quisque quis neque eu diam interdum sagittis. Cras rutrum urna a sem congue, vitae eleifend erat tempor.
Donec suscipit laoreet ligula eget accumsan. In faucibus faucibus massa, quis luctus metus. Donec sit amet felis ut neque finibus volutpat at vehicula turpis. Aenean quis lacus dapibus, sollicitudin dui ac, scelerisque sem. Interdum et malesuada fames ac ante ipsum primis in faucibus. Ut molestie purus sem, a ornare dui volutpat et. Sed ac nisi dui. Cras est nibh, lobortis et dui sit amet, auctor tempus arcu. Sed blandit mi vitae consequat pretium. Integer pretium euismod urna, vitae consequat odio maximus eget. Proin sodales dolor mauris, porttitor convallis nisl imperdiet quis. Donec vel efficitur orci. Pellentesque in mollis magna. Duis tristique faucibus tellus vitae accumsan. Etiam ultrices magna viverra quam auctor dignissim.


text:
<?php

declare(strict_types=1);

namespace Sonata\AdminBundle\Tests\Admin;

use Knp\Menu\ItemInterface;
use Knp\Menu\MenuFactory;
use PHPUnit\Framework\TestCase;
use Sonata\AdminBundle\Admin\AdminInterface;
use Sonata\AdminBundle\Admin\BreadcrumbsBuilder;
use Sonata\AdminBundle\Route\RouteGeneratorInterface;
use Sonata\AdminBundle\Translator\LabelTranslatorStrategyInterface;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\Routing\Generator\UrlGeneratorInterface;

/**
 * This test class contains unit and integration tests. Maybe it could be
 * separated into two classes.
 *
 * @author Grégoire Paris <postmaster@greg0ire.fr>
 */
final class BreadcrumbsBuilderTest extends TestCase
{
    public function testChildGetBreadCrumbs(): void
    {
        $action = 'my_action';
        $breadcrumbsBuilder = new BreadcrumbsBuilder(['child_admin_route' => 'show']);
        $admin = $this->createMock(AdminInterface::class);
        $admin->method('isChild')->willReturn(false);

        $admin->method('getMenuFactory')->willReturn(new MenuFactory());
        $labelTranslatorStrategy = $this->createStub(LabelTranslatorStrategyInterface::class);

        $routeGenerator = $this->createMock(RouteGeneratorInterface::class);
        $routeGenerator->method('generate')->with('sonata_admin_dashboard')->willReturn('/dashboard');

        $admin->method('getRouteGenerator')->willReturn($routeGenerator);
        $labelTranslatorStrategy->method('getLabel')->willReturnMap([
            ['my_class_name_list', 'breadcrumb', 'link', 'My class'],
            ['my_child_class_name_list', 'breadcrumb', 'link', 'My child class'],
        ]);

        $subject = new \stdClass();
        $childSubject = new \stdClass();

        $childAdmin = $this->createMock(AdminInterface::class);
        $childAdmin->method('isChild')->willReturn(true);
        $childAdmin->method('getParent')->willReturn($admin);
        $childAdmin->method('getTranslationDomain')->willReturn('ChildBundle');
        $childAdmin->method('getLabelTranslatorStrategy')->willReturn($labelTranslatorStrategy);
        $childAdmin->method('getClassnameLabel')->willReturn('my_child_class_name');
        $childAdmin->method('hasRoute')->with('list')->willReturn(true);
        $childAdmin->method('hasAccess')->with('list')->willReturn(true);
        $childAdmin->method('generateUrl')->with('list')->willReturn('/myadmin/my-object/mychildadmin/list');
        $childAdmin->method('getCurrentChildAdmin')->willReturn(null);
        $childAdmin->method('hasSubject')->willReturn(true);
        $childAdmin->method('getSubject')->willReturn($childSubject);
        $childAdmin->method('toString')->with($childSubject)->willReturn('My subject');

        $admin->method('hasRoute')->willReturnMap([
            ['show', true],
            ['list', true],
            ['edit', true],
        ]);
        $admin->method('hasAccess')->willReturnMap([
            ['show', $subject, true],
            ['list', null, true],
            ['edit', null, true],
        ]);
        $admin->method('generateUrl')->willReturnMap([
            ['show', ['slug' => 'my-object'], UrlGeneratorInterface::ABSOLUTE_PATH, '/myadmin/my-object'],
            ['edit', ['slug' => 'my-object'], UrlGeneratorInterface::ABSOLUTE_PATH, '/myadmin/my-object'],
            ['list', [], UrlGeneratorInterface::ABSOLUTE_PATH, '/myadmin/list'],
        ]);

        $admin->method('getCurrentChildAdmin')->willReturn($childAdmin);
        $request = $this->createMock(Request::class);
        $request->method('get')->with('slug')->willReturn('my-object');

        $admin->method('getIdParameter')->willReturn('slug');
        $admin->method('getRequest')->willReturn($request);
        $admin->method('hasSubject')->willReturn(true);
        $admin->method('getSubject')->willReturn($subject);
        $admin->method('toString')->with($subject)->willReturn('My subject');
        $admin->method('getTranslationDomain')->willReturn('FooBundle');
        $admin->method('getLabelTranslatorStrategy')->willReturn($labelTranslatorStrategy);
        $admin->method('getClassnameLabel')->willReturn('my_class_name');

        $breadcrumbs = $breadcrumbsBuilder->getBreadcrumbs($childAdmin, $action);
        static::assertCount(5, $breadcrumbs);

        [$dashboardMenu, $adminListMenu, $adminSubjectMenu, $childMenu] = $breadcrumbs;

        static::assertSame('link_breadcrumb_dashboard', $dashboardMenu->getName());
        static::assertSame('/dashboard', $dashboardMenu->getUri());
        static::assertSame(
            ['translation_domain' => 'SonataAdminBundle'],
            $dashboardMenu->getExtras()
        );

        static::assertSame('My class', $adminListMenu->getName());
        static::assertSame('/myadmin/list', $adminListMenu->getUri());
        static::assertSame(
            ['translation_domain' => 'FooBundle'],
            $adminListMenu->getExtras()
        );

        static::assertSame('My subject', $adminSubjectMenu->getName());
        static::assertSame('/myadmin/my-object', $adminSubjectMenu->getUri());
        static::assertSame(
            [
                'translation_domain' => false,
                'safe_label' => false,
            ],
            $adminSubjectMenu->getExtras()
        );

        static::assertSame('My child class', $childMenu->getName());
        static::assertSame('/myadmin/my-object/mychildadmin/list', $childMenu->getUri());
        static::assertSame(
            ['translation_domain' => 'ChildBundle'],
            $childMenu->getExtras()
        );
    }

    /**
     * @phpstan-return array<array{string}>
     */
    public function actionProvider(): array
    {
        return [
            ['my_action'],
            ['list'],
            ['edit'],
            ['create'],
        ];
    }

    /**
     * @dataProvider actionProvider
     */
    public function testBuildBreadcrumbs(string $action): void
    {
        $subject = new \stdClass();

        $breadcrumbsBuilder = new BreadcrumbsBuilder();

        $menu = $this->createMock(ItemInterface::class);
        $menuFactory = $this->createMock(MenuFactory::class);
        $menuFactory->method('createItem')->with('root')->willReturn($menu);
        $admin = $this->createMock(AdminInterface::class);
        $admin->method('getMenuFactory')->willReturn($menuFactory);
        $labelTranslatorStrategy = $this->createStub(LabelTranslatorStrategyInterface::class);

        $routeGenerator = $this->createMock(RouteGeneratorInterface::class);
        $routeGenerator->method('generate')->with('sonata_admin_dashboard')->willReturn('/dashboard');
        $admin->method('getRouteGenerator')->willReturn($routeGenerator);

        $menu->method('addChild')->willReturnMap([
            ['link_breadcrumb_dashboard', [
                'uri' => '/dashboard',
                'extras' => ['translation_domain' => 'SonataAdminBundle'],
            ], $menu],
            ['create my object', [
                'extras' => ['translation_domain' => 'FooBundle'],
            ], $menu],
            ['My class', [
                'extras' => ['translation_domain' => 'FooBundle'],
                'uri' => '/myadmin/list',
            ], $menu],
            ['My subject', [
                'extras' => ['translation_domain' => false],
            ], $menu],
            ['My subject', [
                'uri' => null,
                'extras' => ['translation_domain' => false],
            ], $menu],
            ['My child class', [
                'extras' => ['translation_domain' => 'ChildBundle'],
                'uri' => null,
            ], $menu],
            ['My action', [
                'extras' => ['translation_domain' => 'ChildBundle'],
            ], $menu],
        ]);

        $menu->method('setExtra')->with('safe_label', false)->willReturn($menu);

        $labelTranslatorStrategy->method('getLabel')->willReturnMap([
            ['my_class_name_list', 'breadcrumb', 'link', 'My class'],
            ['my_child_class_name_list', 'breadcrumb', 'link', 'My child class'],
            ['my_child_class_name_my_action', 'breadcrumb', 'link', 'My action'],
            ['my_class_name_create', 'breadcrumb', 'link', 'create my object'],
        ]);

        $childAdmin = $this->createMock(AdminInterface::class);
        $childAdmin->method('getTranslationDomain')->willReturn('ChildBundle');
        $childAdmin->method('getLabelTranslatorStrategy')->willReturn($labelTranslatorStrategy);
        $childAdmin->method('getClassnameLabel')->willReturn('my_child_class_name');
        $childAdmin->method('hasRoute')->with('list')->willReturn(false);
        $childAdmin->method('getCurrentChildAdmin')->willReturn(null);
        $childAdmin->method('hasSubject')->willReturn(false);

        $admin->method('hasRoute')->willReturnMap([
            ['list', true],
            ['show', false],
        ]);
        $admin->method('hasAccess')->with('list')->willReturn(true);
        $admin->method('generateUrl')->with('list')->willReturn('/myadmin/list');
        $admin->method('getCurrentChildAdmin')->willReturn('my_action' === $action ? $childAdmin : null);

        if ('list' === $action) {
            $admin->method('isChild')->willReturn(true);
            $menu->expects(static::once())->method('setUri')->with(null);
        } else {
            $menu->expects(static::never())->method('setUri');
        }

        $request = $this->createMock(Request::class);
        $request->method('get')->with('slug')->willReturn('my-object');

        $admin->method('getIdParameter')->willReturn('slug');
        $admin->method('getRequest')->willReturn($request);
        $admin->method('hasSubject')->willReturn(true);
        $admin->method('getSubject')->willReturn($subject);
        $admin->method('toString')->with($subject)->willReturn('My subject');
        $admin->method('getTranslationDomain')->willReturn('FooBundle');
        $admin->method('getLabelTranslatorStrategy')->willReturn($labelTranslatorStrategy);
        $admin->method('getClassnameLabel')->willReturn('my_class_name');

        $breadcrumbsBuilder->buildBreadcrumbs($admin, $action);
    }
}


text:
action buttons: FindSpecificActionCancel
#If the user decides to cancel their the find, then return
#to the main record window and show all records.
Go to Layout [ "Issues" (issue) ]
Enter Find Mode [ ]
Set Field [ issue::_keyBrainstate; $$logBrainstate ]
Perform Find [ ]
Show/Hide Status Area
[ Hide ]
Show/Hide Text Ruler
[ Hide ]
Sort Records [ ]
[ No dialog ]
Go to Record/Request/Page
[ First ]
Halt Script
January 5, 平成26 19:50:04 ActionLog.fp7 - FindSpecificActionCancel -1-


text:
<!DOCTYPE html>
<html>
<script>
  internals.settings.setViewportEnabled(true);
  internals.settings.setViewportMetaEnabled(true);
</script>
<head>
<title>Test that no overflow with a small viewport clips the controls</title>
<meta name='viewport' content='width=300'>
<script src="../resources/testharness.js"></script>
<script src="../resources/testharnessreport.js"></script>
<script src="media-file.js"></script>
<script src="media-controls.js"></script>
</head>
<body>
  <video controls width=400></video>
  <video controls width=800></video>
  <video controls width=1200></video>
  <video controls width=600 style='padding: 100px'></video>
</body>
<script>
test(_ => {
  const expectedWidth = [
    "400px",
    "800px",
    "1200px",
    "600px",
  ];

  var videos = document.querySelectorAll('video');
  for (var i=0; i < videos.length; ++i) {
    videos[i].src = findMediaFile('video', 'content/test');
  }

  var forceLayout = document.body.offsetHeight;

  for (var i=0; i < videos.length; ++i) {
    var controls = mediaControlsButton(videos[i], 'panel');
    assert_equals(getComputedStyle(controls).width, expectedWidth[i]);
  }
});
</script>
</html>


text:
package org.jeecqrs.common.event.sourcing;

import org.jeecqrs.common.event.Event;

/**
 * Provides the ability to store a changes made during event sourcing.
 *
 * @param <E>  the base event type
 */
public interface EventSourcingBus<E extends Event> {

    void store(E event);
    void commit(String commitId);

}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<TITLE>
org.junit.runner.manipulation (JUnit API)
</TITLE>

<META NAME="keywords" CONTENT="org.junit.runner.manipulation package">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../../stylesheet.css" TITLE="Style">

      Overview
    Package
      Class
      Tree
      Deprecated
      Index
      Help

 PREV PACKAGE
 NEXT PACKAGE

  FRAMES
 NO FRAMES

  All Classes

Package org.junit.runner.manipulation

Provides classes to filter or sort tests.

See:

          Description

Interface Summary

Filterable
Runners that allow filtering should implement this interface.

Sortable
Interface for runners that allow sorting of tests.

Class Summary

Filter
The canonical case of filtering is when you want to run a single test method in a class.

Sorter
A Sorter orders tests.

Exception Summary

NoTestsRemainException
Thrown when a filter removes all tests from a runner.

Package org.junit.runner.manipulation Description

Provides classes to filter or sort tests.

Since:

4.0

See Also:
Runner

      Overview
    Package
      Class
      Tree
      Deprecated
      Index
      Help

 PREV PACKAGE
 NEXT PACKAGE

  FRAMES
 NO FRAMES

  All Classes


text:
#include <linux/slab.h>
#include <linux/time.h>
#include <linux/signal.h>
#include <linux/file.h>
#include "autofs_i.h"

/* We make this a static variable rather than a part of the superblock; it
 * is better if we don't reassign numbers easily even across filesystems
 */
static autofs_wqt_t autofs4_next_wait_queue = 1;

/* These are the signals we allow interrupting a pending mount */
#define SHUTDOWN_SIGS	(sigmask(SIGKILL) | sigmask(SIGINT) | sigmask(SIGQUIT))

void autofs4_catatonic_mode(struct autofs_sb_info *sbi)
{
	struct autofs_wait_queue *wq, *nwq;

	mutex_lock(&sbi->wq_mutex);
	if (sbi->catatonic) {
		mutex_unlock(&sbi->wq_mutex);
		return;
	}

	pr_debug("entering catatonic mode\n");

	sbi->catatonic = 1;
	wq = sbi->queues;
	sbi->queues = NULL;	/* Erase all wait queues */
	while (wq) {
		nwq = wq->next;
		wq->status = -ENOENT; /* Magic is gone - report failure */
		kfree(wq->name.name);
		wq->name.name = NULL;
		wq->wait_ctr--;
		wake_up_interruptible(&wq->queue);
		wq = nwq;
	}
	fput(sbi->pipe);	/* Close the pipe */
	sbi->pipe = NULL;
	sbi->pipefd = -1;
	mutex_unlock(&sbi->wq_mutex);
}

static int autofs4_write(struct autofs_sb_info *sbi,
			 struct file *file, const void *addr, int bytes)
{
	unsigned long sigpipe, flags;
	mm_segment_t fs;
	const char *data = (const char *)addr;
	ssize_t wr = 0;

	sigpipe = sigismember(&current->pending.signal, SIGPIPE);

	/* Save pointer to user space and point back to kernel space */
	fs = get_fs();
	set_fs(KERNEL_DS);

	mutex_lock(&sbi->pipe_mutex);
	while (bytes) {
		wr = __vfs_write(file, data, bytes, &file->f_pos);
		if (wr <= 0)
			break;
		data += wr;
		bytes -= wr;
	}
	mutex_unlock(&sbi->pipe_mutex);

	set_fs(fs);

	/* Keep the currently executing process from receiving a
	 * SIGPIPE unless it was already supposed to get one
	 */
	if (wr == -EPIPE && !sigpipe) {
		spin_lock_irqsave(&current->sighand->siglock, flags);
		sigdelset(&current->pending.signal, SIGPIPE);
		recalc_sigpending();
		spin_unlock_irqrestore(&current->sighand->siglock, flags);
	}

	return (bytes > 0);
}

static void autofs4_notify_daemon(struct autofs_sb_info *sbi,
				 struct autofs_wait_queue *wq,
				 int type)
{
	union {
		struct autofs_packet_hdr hdr;
		union autofs_packet_union v4_pkt;
		union autofs_v5_packet_union v5_pkt;
	} pkt;
	struct file *pipe = NULL;
	size_t pktsz;

	pr_debug("wait id = 0x%08lx, name = %.*s, type=%d\n",
		 (unsigned long) wq->wait_queue_token,
		 wq->name.len, wq->name.name, type);

	memset(&pkt, 0, sizeof(pkt)); /* For security reasons */

	pkt.hdr.proto_version = sbi->version;
	pkt.hdr.type = type;

	switch (type) {
	/* Kernel protocol v4 missing and expire packets */
	case autofs_ptype_missing:
	{
		struct autofs_packet_missing *mp = &pkt.v4_pkt.missing;

		pktsz = sizeof(*mp);

		mp->wait_queue_token = wq->wait_queue_token;
		mp->len = wq->name.len;
		memcpy(mp->name, wq->name.name, wq->name.len);
		mp->name[wq->name.len] = '\0';
		break;
	}
	case autofs_ptype_expire_multi:
	{
		struct autofs_packet_expire_multi *ep =
					&pkt.v4_pkt.expire_multi;

		pktsz = sizeof(*ep);

		ep->wait_queue_token = wq->wait_queue_token;
		ep->len = wq->name.len;
		memcpy(ep->name, wq->name.name, wq->name.len);
		ep->name[wq->name.len] = '\0';
		break;
	}
	/*
	 * Kernel protocol v5 packet for handling indirect and direct
	 * mount missing and expire requests
	 */
	case autofs_ptype_missing_indirect:
	case autofs_ptype_expire_indirect:
	case autofs_ptype_missing_direct:
	case autofs_ptype_expire_direct:
	{
		struct autofs_v5_packet *packet = &pkt.v5_pkt.v5_packet;
		struct user_namespace *user_ns = sbi->pipe->f_cred->user_ns;

		pktsz = sizeof(*packet);

		packet->wait_queue_token = wq->wait_queue_token;
		packet->len = wq->name.len;
		memcpy(packet->name, wq->name.name, wq->name.len);
		packet->name[wq->name.len] = '\0';
		packet->dev = wq->dev;
		packet->ino = wq->ino;
		packet->uid = from_kuid_munged(user_ns, wq->uid);
		packet->gid = from_kgid_munged(user_ns, wq->gid);
		packet->pid = wq->pid;
		packet->tgid = wq->tgid;
		break;
	}
	default:
		pr_warn("bad type %d!\n", type);
		mutex_unlock(&sbi->wq_mutex);
		return;
	}

	pipe = get_file(sbi->pipe);

	mutex_unlock(&sbi->wq_mutex);

	if (autofs4_write(sbi, pipe, &pkt, pktsz))
		autofs4_catatonic_mode(sbi);
	fput(pipe);
}

static int autofs4_getpath(struct autofs_sb_info *sbi,
			   struct dentry *dentry, char **name)
{
	struct dentry *root = sbi->sb->s_root;
	struct dentry *tmp;
	char *buf;
	char *p;
	int len;
	unsigned seq;

rename_retry:
	buf = *name;
	len = 0;

	seq = read_seqbegin(&rename_lock);
	rcu_read_lock();
	spin_lock(&sbi->fs_lock);
	for (tmp = dentry ; tmp != root ; tmp = tmp->d_parent)
		len += tmp->d_name.len + 1;

	if (!len || --len > NAME_MAX) {
		spin_unlock(&sbi->fs_lock);
		rcu_read_unlock();
		if (read_seqretry(&rename_lock, seq))
			goto rename_retry;
		return 0;
	}

	*(buf + len) = '\0';
	p = buf + len - dentry->d_name.len;
	strncpy(p, dentry->d_name.name, dentry->d_name.len);

	for (tmp = dentry->d_parent; tmp != root ; tmp = tmp->d_parent) {
		*(--p) = '/';
		p -= tmp->d_name.len;
		strncpy(p, tmp->d_name.name, tmp->d_name.len);
	}
	spin_unlock(&sbi->fs_lock);
	rcu_read_unlock();
	if (read_seqretry(&rename_lock, seq))
		goto rename_retry;

	return len;
}

static struct autofs_wait_queue *
autofs4_find_wait(struct autofs_sb_info *sbi, struct qstr *qstr)
{
	struct autofs_wait_queue *wq;

	for (wq = sbi->queues; wq; wq = wq->next) {
		if (wq->name.hash == qstr->hash &&
		    wq->name.len == qstr->len &&
		    wq->name.name &&
		    !memcmp(wq->name.name, qstr->name, qstr->len))
			break;
	}
	return wq;
}

/*
 * Check if we have a valid request.
 * Returns
 * 1 if the request should continue.
 *   In this case we can return an autofs_wait_queue entry if one is
 *   found or NULL to idicate a new wait needs to be created.
 * 0 or a negative errno if the request shouldn't continue.
 */
static int validate_request(struct autofs_wait_queue **wait,
			    struct autofs_sb_info *sbi,
			    struct qstr *qstr,
			    struct dentry *dentry, enum autofs_notify notify)
{
	struct autofs_wait_queue *wq;
	struct autofs_info *ino;

	if (sbi->catatonic)
		return -ENOENT;

	/* Wait in progress, continue; */
	wq = autofs4_find_wait(sbi, qstr);
	if (wq) {
		*wait = wq;
		return 1;
	}

	*wait = NULL;

	/* If we don't yet have any info this is a new request */
	ino = autofs4_dentry_ino(dentry);
	if (!ino)
		return 1;

	/*
	 * If we've been asked to wait on an existing expire (NFY_NONE)
	 * but there is no wait in the queue ...
	 */
	if (notify == NFY_NONE) {
		/*
		 * Either we've betean the pending expire to post it's
		 * wait or it finished while we waited on the mutex.
		 * So we need to wait till either, the wait appears
		 * or the expire finishes.
		 */

		while (ino->flags & AUTOFS_INF_EXPIRING) {
			mutex_unlock(&sbi->wq_mutex);
			schedule_timeout_interruptible(HZ/10);
			if (mutex_lock_interruptible(&sbi->wq_mutex))
				return -EINTR;

			if (sbi->catatonic)
				return -ENOENT;

			wq = autofs4_find_wait(sbi, qstr);
			if (wq) {
				*wait = wq;
				return 1;
			}
		}

		/*
		 * Not ideal but the status has already gone. Of the two
		 * cases where we wait on NFY_NONE neither depend on the
		 * return status of the wait.
		 */
		return 0;
	}

	/*
	 * If we've been asked to trigger a mount and the request
	 * completed while we waited on the mutex ...
	 */
	if (notify == NFY_MOUNT) {
		struct dentry *new = NULL;
		int valid = 1;

		/*
		 * If the dentry was successfully mounted while we slept
		 * on the wait queue mutex we can return success. If it
		 * isn't mounted (doesn't have submounts for the case of
		 * a multi-mount with no mount at it's base) we can
		 * continue on and create a new request.
		 */
		if (!IS_ROOT(dentry)) {
			if (d_unhashed(dentry) &&
			    d_really_is_positive(dentry)) {
				struct dentry *parent = dentry->d_parent;

				new = d_lookup(parent, &dentry->d_name);
				if (new)
					dentry = new;
			}
		}
		if (have_submounts(dentry))
			valid = 0;

		if (new)
			dput(new);
		return valid;
	}

	return 1;
}

int autofs4_wait(struct autofs_sb_info *sbi,
		 struct dentry *dentry, enum autofs_notify notify)
{
	struct autofs_wait_queue *wq;
	struct qstr qstr;
	char *name;
	int status, ret, type;
	pid_t pid;
	pid_t tgid;

	/* In catatonic mode, we don't wait for nobody */
	if (sbi->catatonic)
		return -ENOENT;

	/*
	 * Try translating pids to the namespace of the daemon.
	 *
	 * Zero means failure: we are in an unrelated pid namespace.
	 */
	pid = task_pid_nr_ns(current, ns_of_pid(sbi->oz_pgrp));
	tgid = task_tgid_nr_ns(current, ns_of_pid(sbi->oz_pgrp));
	if (pid == 0 || tgid == 0)
		return -ENOENT;

	if (d_really_is_negative(dentry)) {
		/*
		 * A wait for a negative dentry is invalid for certain
		 * cases. A direct or offset mount "always" has its mount
		 * point directory created and so the request dentry must
		 * be positive or the map key doesn't exist. The situation
		 * is very similar for indirect mounts except only dentrys
		 * in the root of the autofs file system may be negative.
		 */
		if (autofs_type_trigger(sbi->type))
			return -ENOENT;
		else if (!IS_ROOT(dentry->d_parent))
			return -ENOENT;
	}

	name = kmalloc(NAME_MAX + 1, GFP_KERNEL);
	if (!name)
		return -ENOMEM;

	/* If this is a direct mount request create a dummy name */
	if (IS_ROOT(dentry) && autofs_type_trigger(sbi->type))
		qstr.len = sprintf(name, "%p", dentry);
	else {
		qstr.len = autofs4_getpath(sbi, dentry, &name);
		if (!qstr.len) {
			kfree(name);
			return -ENOENT;
		}
	}
	qstr.name = name;
	qstr.hash = full_name_hash(name, qstr.len);

	if (mutex_lock_interruptible(&sbi->wq_mutex)) {
		kfree(qstr.name);
		return -EINTR;
	}

	ret = validate_request(&wq, sbi, &qstr, dentry, notify);
	if (ret <= 0) {
		if (ret != -EINTR)
			mutex_unlock(&sbi->wq_mutex);
		kfree(qstr.name);
		return ret;
	}

	if (!wq) {
		/* Create a new wait queue */
		wq = kmalloc(sizeof(struct autofs_wait_queue), GFP_KERNEL);
		if (!wq) {
			kfree(qstr.name);
			mutex_unlock(&sbi->wq_mutex);
			return -ENOMEM;
		}

		wq->wait_queue_token = autofs4_next_wait_queue;
		if (++autofs4_next_wait_queue == 0)
			autofs4_next_wait_queue = 1;
		wq->next = sbi->queues;
		sbi->queues = wq;
		init_waitqueue_head(&wq->queue);
		memcpy(&wq->name, &qstr, sizeof(struct qstr));
		wq->dev = autofs4_get_dev(sbi);
		wq->ino = autofs4_get_ino(sbi);
		wq->uid = current_uid();
		wq->gid = current_gid();
		wq->pid = pid;
		wq->tgid = tgid;
		wq->status = -EINTR; /* Status return if interrupted */
		wq->wait_ctr = 2;

		if (sbi->version < 5) {
			if (notify == NFY_MOUNT)
				type = autofs_ptype_missing;
			else
				type = autofs_ptype_expire_multi;
		} else {
			if (notify == NFY_MOUNT)
				type = autofs_type_trigger(sbi->type) ?
					autofs_ptype_missing_direct :
					 autofs_ptype_missing_indirect;
			else
				type = autofs_type_trigger(sbi->type) ?
					autofs_ptype_expire_direct :
					autofs_ptype_expire_indirect;
		}

		pr_debug("new wait id = 0x%08lx, name = %.*s, nfy=%d\n",
			 (unsigned long) wq->wait_queue_token, wq->name.len,
			 wq->name.name, notify);

		/*
		 * autofs4_notify_daemon() may block; it will unlock ->wq_mutex
		 */
		autofs4_notify_daemon(sbi, wq, type);
	} else {
		wq->wait_ctr++;
		pr_debug("existing wait id = 0x%08lx, name = %.*s, nfy=%d\n",
			 (unsigned long) wq->wait_queue_token, wq->name.len,
			 wq->name.name, notify);
		mutex_unlock(&sbi->wq_mutex);
		kfree(qstr.name);
	}

	/*
	 * wq->name.name is NULL iff the lock is already released
	 * or the mount has been made catatonic.
	 */
	if (wq->name.name) {
		/* Block all but "shutdown" signals while waiting */
		unsigned long shutdown_sigs_mask;
		unsigned long irqflags;
		sigset_t oldset;

		spin_lock_irqsave(&current->sighand->siglock, irqflags);
		oldset = current->blocked;
		shutdown_sigs_mask = SHUTDOWN_SIGS & ~oldset.sig[0];
		siginitsetinv(&current->blocked, shutdown_sigs_mask);
		recalc_sigpending();
		spin_unlock_irqrestore(&current->sighand->siglock, irqflags);

		wait_event_interruptible(wq->queue, wq->name.name == NULL);

		spin_lock_irqsave(&current->sighand->siglock, irqflags);
		current->blocked = oldset;
		recalc_sigpending();
		spin_unlock_irqrestore(&current->sighand->siglock, irqflags);
	} else {
		pr_debug("skipped sleeping\n");
	}

	status = wq->status;

	/*
	 * For direct and offset mounts we need to track the requester's
	 * uid and gid in the dentry info struct. This is so it can be
	 * supplied, on request, by the misc device ioctl interface.
	 * This is needed during daemon resatart when reconnecting
	 * to existing, active, autofs mounts. The uid and gid (and
	 * related string values) may be used for macro substitution
	 * in autofs mount maps.
	 */
	if (!status) {
		struct autofs_info *ino;
		struct dentry *de = NULL;

		/* direct mount or browsable map */
		ino = autofs4_dentry_ino(dentry);
		if (!ino) {
			/* If not lookup actual dentry used */
			de = d_lookup(dentry->d_parent, &dentry->d_name);
			if (de)
				ino = autofs4_dentry_ino(de);
		}

		/* Set mount requester */
		if (ino) {
			spin_lock(&sbi->fs_lock);
			ino->uid = wq->uid;
			ino->gid = wq->gid;
			spin_unlock(&sbi->fs_lock);
		}

		if (de)
			dput(de);
	}

	/* Are we the last process to need status? */
	mutex_lock(&sbi->wq_mutex);
	if (!--wq->wait_ctr)
		kfree(wq);
	mutex_unlock(&sbi->wq_mutex);

	return status;
}

int autofs4_wait_release(struct autofs_sb_info *sbi, autofs_wqt_t wait_queue_token, int status)
{
	struct autofs_wait_queue *wq, **wql;

	mutex_lock(&sbi->wq_mutex);
	for (wql = &sbi->queues; (wq = *wql) != NULL; wql = &wq->next) {
		if (wq->wait_queue_token == wait_queue_token)
			break;
	}

	if (!wq) {
		mutex_unlock(&sbi->wq_mutex);
		return -EINVAL;
	}

	*wql = wq->next;	/* Unlink from chain */
	kfree(wq->name.name);
	wq->name.name = NULL;	/* Do not wait on this queue */
	wq->status = status;
	wake_up_interruptible(&wq->queue);
	if (!--wq->wait_ctr)
		kfree(wq);
	mutex_unlock(&sbi->wq_mutex);

	return 0;
}


text:
package cortex.controller

import cortex.controller.ContentType._
import cortex.model.{Primitive, ActionContext, Request}

/**
  * Created by jasonflax on 2/19/16.
  */
case class Action(handler: (Request) => Message[_],
                  contentType: ContentType,
                  actionContext: ActionContext,
                  methods: Seq[HttpVerb[_ <: Primitive[_]]])


text:
var Backbone = require('backbone');

module.exports = Backbone.View.extend({

  // template: require('../templates/notifications.jst'),

  events: {
  },

  initialize: function() {
  }

});


text:
#include "modules/webdatabase/DatabaseAuthorizer.h"

#include "wtf/HashSet.h"
#include "wtf/StdLibExtras.h"
#include "wtf/Threading.h"
#include "wtf/text/StringHash.h"

namespace blink {

DatabaseAuthorizer* DatabaseAuthorizer::create(
    const String& databaseInfoTableName) {
  return new DatabaseAuthorizer(databaseInfoTableName);
}

DatabaseAuthorizer::DatabaseAuthorizer(const String& databaseInfoTableName)
    : m_securityEnabled(false), m_databaseInfoTableName(databaseInfoTableName) {
  DCHECK(isMainThread());

  reset();
}

void DatabaseAuthorizer::reset() {
  m_lastActionWasInsert = false;
  m_lastActionChangedDatabase = false;
  m_permissions = ReadWriteMask;
}

void DatabaseAuthorizer::resetDeletes() {
  m_hadDeletes = false;
}

namespace {
using FunctionNameList = HashSet<String, CaseFoldingHash>;

const FunctionNameList& whitelistedFunctions() {
  DEFINE_THREAD_SAFE_STATIC_LOCAL(
      FunctionNameList, list,
      new FunctionNameList({
          // SQLite functions used to help implement some operations
          // ALTER TABLE helpers
          "sqlite_rename_table", "sqlite_rename_trigger",
          // GLOB helpers
          "glob",
          // SQLite core functions
          "abs", "changes", "coalesce", "glob", "ifnull", "hex",
          "last_insert_rowid", "length", "like", "lower", "ltrim", "max", "min",
          "nullif", "quote", "replace", "round", "rtrim", "soundex",
          "sqlite_source_id", "sqlite_version", "substr", "total_changes",
          "trim", "typeof", "upper", "zeroblob",
          // SQLite date and time functions
          "date", "time", "datetime", "julianday", "strftime",
          // SQLite aggregate functions
          // max() and min() are already in the list
          "avg", "count", "group_concat", "sum", "total",
          // SQLite FTS functions
          "match", "snippet", "offsets", "optimize",
          // SQLite ICU functions
          // like(), lower() and upper() are already in the list
          "regexp",
      }));
  return list;
}
}

int DatabaseAuthorizer::createTable(const String& tableName) {
  if (!allowWrite())
    return SQLAuthDeny;

  m_lastActionChangedDatabase = true;
  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::createTempTable(const String& tableName) {
  // SQLITE_CREATE_TEMP_TABLE results in a UPDATE operation, which is not
  // allowed in read-only transactions or private browsing, so we might as
  // well disallow SQLITE_CREATE_TEMP_TABLE in these cases
  if (!allowWrite())
    return SQLAuthDeny;

  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::dropTable(const String& tableName) {
  if (!allowWrite())
    return SQLAuthDeny;

  return updateDeletesBasedOnTableName(tableName);
}

int DatabaseAuthorizer::dropTempTable(const String& tableName) {
  // SQLITE_DROP_TEMP_TABLE results in a DELETE operation, which is not
  // allowed in read-only transactions or private browsing, so we might as
  // well disallow SQLITE_DROP_TEMP_TABLE in these cases
  if (!allowWrite())
    return SQLAuthDeny;

  return updateDeletesBasedOnTableName(tableName);
}

int DatabaseAuthorizer::allowAlterTable(const String&,
                                        const String& tableName) {
  if (!allowWrite())
    return SQLAuthDeny;

  m_lastActionChangedDatabase = true;
  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::createIndex(const String&, const String& tableName) {
  if (!allowWrite())
    return SQLAuthDeny;

  m_lastActionChangedDatabase = true;
  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::createTempIndex(const String&,
                                        const String& tableName) {
  // SQLITE_CREATE_TEMP_INDEX should result in a UPDATE or INSERT operation,
  // which is not allowed in read-only transactions or private browsing,
  // so we might as well disallow SQLITE_CREATE_TEMP_INDEX in these cases
  if (!allowWrite())
    return SQLAuthDeny;

  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::dropIndex(const String&, const String& tableName) {
  if (!allowWrite())
    return SQLAuthDeny;

  return updateDeletesBasedOnTableName(tableName);
}

int DatabaseAuthorizer::dropTempIndex(const String&, const String& tableName) {
  // SQLITE_DROP_TEMP_INDEX should result in a DELETE operation, which is
  // not allowed in read-only transactions or private browsing, so we might
  // as well disallow SQLITE_DROP_TEMP_INDEX in these cases
  if (!allowWrite())
    return SQLAuthDeny;

  return updateDeletesBasedOnTableName(tableName);
}

int DatabaseAuthorizer::createTrigger(const String&, const String& tableName) {
  if (!allowWrite())
    return SQLAuthDeny;

  m_lastActionChangedDatabase = true;
  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::createTempTrigger(const String&,
                                          const String& tableName) {
  // SQLITE_CREATE_TEMP_TRIGGER results in a INSERT operation, which is not
  // allowed in read-only transactions or private browsing, so we might as
  // well disallow SQLITE_CREATE_TEMP_TRIGGER in these cases
  if (!allowWrite())
    return SQLAuthDeny;

  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::dropTrigger(const String&, const String& tableName) {
  if (!allowWrite())
    return SQLAuthDeny;

  return updateDeletesBasedOnTableName(tableName);
}

int DatabaseAuthorizer::dropTempTrigger(const String&,
                                        const String& tableName) {
  // SQLITE_DROP_TEMP_TRIGGER results in a DELETE operation, which is not
  // allowed in read-only transactions or private browsing, so we might as
  // well disallow SQLITE_DROP_TEMP_TRIGGER in these cases
  if (!allowWrite())
    return SQLAuthDeny;

  return updateDeletesBasedOnTableName(tableName);
}

int DatabaseAuthorizer::createView(const String&) {
  return (!allowWrite() ? SQLAuthDeny : SQLAuthAllow);
}

int DatabaseAuthorizer::createTempView(const String&) {
  // SQLITE_CREATE_TEMP_VIEW results in a UPDATE operation, which is not
  // allowed in read-only transactions or private browsing, so we might as
  // well disallow SQLITE_CREATE_TEMP_VIEW in these cases
  return (!allowWrite() ? SQLAuthDeny : SQLAuthAllow);
}

int DatabaseAuthorizer::dropView(const String&) {
  if (!allowWrite())
    return SQLAuthDeny;

  m_hadDeletes = true;
  return SQLAuthAllow;
}

int DatabaseAuthorizer::dropTempView(const String&) {
  // SQLITE_DROP_TEMP_VIEW results in a DELETE operation, which is not
  // allowed in read-only transactions or private browsing, so we might as
  // well disallow SQLITE_DROP_TEMP_VIEW in these cases
  if (!allowWrite())
    return SQLAuthDeny;

  m_hadDeletes = true;
  return SQLAuthAllow;
}

int DatabaseAuthorizer::createVTable(const String& tableName,
                                     const String& moduleName) {
  if (!allowWrite())
    return SQLAuthDeny;

  // Allow only the FTS3 extension
  if (!equalIgnoringCase(moduleName, "fts3"))
    return SQLAuthDeny;

  m_lastActionChangedDatabase = true;
  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::dropVTable(const String& tableName,
                                   const String& moduleName) {
  if (!allowWrite())
    return SQLAuthDeny;

  // Allow only the FTS3 extension
  if (!equalIgnoringCase(moduleName, "fts3"))
    return SQLAuthDeny;

  return updateDeletesBasedOnTableName(tableName);
}

int DatabaseAuthorizer::allowDelete(const String& tableName) {
  if (!allowWrite())
    return SQLAuthDeny;

  return updateDeletesBasedOnTableName(tableName);
}

int DatabaseAuthorizer::allowInsert(const String& tableName) {
  if (!allowWrite())
    return SQLAuthDeny;

  m_lastActionChangedDatabase = true;
  m_lastActionWasInsert = true;
  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::allowUpdate(const String& tableName, const String&) {
  if (!allowWrite())
    return SQLAuthDeny;

  m_lastActionChangedDatabase = true;
  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::allowTransaction() {
  return m_securityEnabled ? SQLAuthDeny : SQLAuthAllow;
}

int DatabaseAuthorizer::allowRead(const String& tableName, const String&) {
  if (m_permissions & NoAccessMask && m_securityEnabled)
    return SQLAuthDeny;

  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::allowReindex(const String&) {
  return (!allowWrite() ? SQLAuthDeny : SQLAuthAllow);
}

int DatabaseAuthorizer::allowAnalyze(const String& tableName) {
  return denyBasedOnTableName(tableName);
}

int DatabaseAuthorizer::allowPragma(const String&, const String&) {
  return m_securityEnabled ? SQLAuthDeny : SQLAuthAllow;
}

int DatabaseAuthorizer::allowAttach(const String&) {
  return m_securityEnabled ? SQLAuthDeny : SQLAuthAllow;
}

int DatabaseAuthorizer::allowDetach(const String&) {
  return m_securityEnabled ? SQLAuthDeny : SQLAuthAllow;
}

int DatabaseAuthorizer::allowFunction(const String& functionName) {
  if (m_securityEnabled && !whitelistedFunctions().contains(functionName))
    return SQLAuthDeny;

  return SQLAuthAllow;
}

void DatabaseAuthorizer::disable() {
  m_securityEnabled = false;
}

void DatabaseAuthorizer::enable() {
  m_securityEnabled = true;
}

bool DatabaseAuthorizer::allowWrite() {
  return !(m_securityEnabled &&
           (m_permissions & ReadOnlyMask || m_permissions & NoAccessMask));
}

void DatabaseAuthorizer::setPermissions(int permissions) {
  m_permissions = permissions;
}

int DatabaseAuthorizer::denyBasedOnTableName(const String& tableName) const {
  if (!m_securityEnabled)
    return SQLAuthAllow;

  // Sadly, normal creates and drops end up affecting sqlite_master in an
  // authorizer callback, so it will be tough to enforce all of the following
  // policies:
  // if (equalIgnoringCase(tableName, "sqlite_master") ||
  //     equalIgnoringCase(tableName, "sqlite_temp_master") ||
  //     equalIgnoringCase(tableName, "sqlite_sequence") ||
  //     equalIgnoringCase(tableName, Database::databaseInfoTableName()))
  //   return SQLAuthDeny;

  if (equalIgnoringCase(tableName, m_databaseInfoTableName))
    return SQLAuthDeny;

  return SQLAuthAllow;
}

int DatabaseAuthorizer::updateDeletesBasedOnTableName(const String& tableName) {
  int allow = denyBasedOnTableName(tableName);
  if (allow)
    m_hadDeletes = true;
  return allow;
}

}  // namespace blink


text:
'''Test RGB load using PIL.  You should see the rgb.png image on
a checkboard background.
'''

__docformat__ = 'restructuredtext'
__version__ = '$Id: $'

import unittest
import base_load

from pyglet.image.codecs.pil import *

class TEST_PIL_RGB_LOAD(base_load.TestLoad):
    texture_file = 'rgb.png'
    decoder = PILImageDecoder()

if __name__ == '__main__':
    unittest.main()


text:
from __future__ import unicode_literals
from seq2seq.tools.config import *
from copy import deepcopy
from .multi_language import MultiLanguageDataset

class WMT(MultiLanguageDataset):
    """WMT dataset class"""

    def __init__(self,
                 root,
                 split='train',
                 tokenization='bpe',
                 tokenization_config={},
                 tokenization_model_files=None,
                 shared_vocab=True,
                 insert_start=[BOS],
                 insert_end=[EOS],
                 mark_language=False,
                 tokenizers=None,
                 vocab_limit=None,
                 moses_pretok=True,
                 languages=['en', 'de'],
                 train_file="{root}/train{pretok}.clean",
                 val_file="{root}/newstest2014{pretok}.clean",
                 test_file="{root}/newstest2016{pretok}.clean",
                 load_data=True,
                 sample=False):
        pretok = ''
        sample = sample if split == 'train' else False
        if moses_pretok:
            pretok = '.tok'
            tokenization = 'moses+' + tokenization
        train_prefix = train_file.format(root=root, pretok=pretok)
        options = dict(
            prefix=train_prefix,
            languages=languages,
            tokenization=tokenization,
            tokenization_config=tokenization_config,
            tokenization_model_files=tokenization_model_files,
            shared_vocab=shared_vocab,
            insert_start=insert_start,
            insert_end=insert_end,
            mark_language=mark_language,
            tokenizers=tokenizers,
            vocab_limit=vocab_limit,
            load_data=False,
            sample=sample
        )
        train_options = deepcopy(options)

        if split == 'train':
            options = train_options
        else:
            train_data = MultiLanguageDataset(**train_options)
            options['tokenizers'] = getattr(train_data, 'tokenizers', None)
            options['tokenization_model_files'] = getattr(
                train_data, 'tokenization_model_files', None)
            if split == 'dev':
                prefix = val_file.format(root=root, pretok=pretok)
            elif split == 'test':
                prefix = test_file.format(root=root, pretok=pretok)

            options['prefix'] = prefix
        super(WMT, self).__init__(**options)
        if load_data:
            self.load_data()

class WMT16_de_en(WMT):
    """docstring for Dataset."""

    def __init__(self, *kargs, **kwargs):
        super(WMT16_de_en, self).__init__(*kargs, **kwargs)

class WMT17_de_en(WMT):
    """docstring for Dataset."""

    def __init__(self, *kargs, **kwargs):
        kwargs.setdefault('test_file', "{root}/newstest2017{pretok}.clean")
        super(WMT17_de_en, self).__init__(*kargs, **kwargs)


text:
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE OverloadedStrings   #-}
{-# LANGUAGE RecordWildCards     #-}
{-# LANGUAGE ScopedTypeVariables #-}
{-# OPTIONS_GHC -fno-warn-unused-do-bind #-}

module PureScript.Ide.Externs
  (
    ExternDecl(..),
    ModuleIdent,
    DeclIdent,
    Type,
    Fixity(..),
    readExternFile,
    convertExterns,
    unwrapPositioned,
    unwrapPositionedRef
  ) where

import           Data.Maybe                  (mapMaybe)
import           Control.Monad.Except
import           Data.Text (Text)
import qualified Data.Text                   as T
import qualified Data.Text.IO                as T
import qualified Language.PureScript.Externs as PE
import qualified Language.PureScript.AST.Declarations as D
import qualified Language.PureScript.Names   as N
import qualified Language.PureScript.Pretty  as PP
import           PureScript.Ide.CodecJSON
import           PureScript.Ide.Error        (PscIdeError (..))
import           PureScript.Ide.Types

readExternFile :: (MonadIO m, MonadError PscIdeError m) =>
                  FilePath -> m PE.ExternsFile
readExternFile fp = do
   parseResult <- liftIO (decodeT <$> T.readFile fp)
   case parseResult of
     Nothing -> throwError . GeneralError $ "Parsing the extern at: " ++ fp ++ " failed"
     Just externs -> pure externs

moduleNameToText :: N.ModuleName -> Text
moduleNameToText = T.pack . N.runModuleName

properNameToText :: N.ProperName a -> Text
properNameToText = T.pack . N.runProperName

identToText :: N.Ident -> Text
identToText  = T.pack . N.runIdent

convertExterns :: PE.ExternsFile -> Module
convertExterns ef = (moduleName, exportDecls ++ importDecls ++ otherDecls)
  where
    moduleName = moduleNameToText (PE.efModuleName ef)
    importDecls = convertImport <$> PE.efImports ef
    exportDecls = mapMaybe (convertExport . unwrapPositionedRef) (PE.efExports ef)
    -- Ignoring operator fixities for now since we're not using them
    -- operatorDecls = convertOperator <$> PE.efFixities ef
    otherDecls = mapMaybe convertDecl (PE.efDeclarations ef)

convertImport :: PE.ExternsImport -> ExternDecl
convertImport ei =
  Dependency
  (moduleNameToText (PE.eiModule ei))
  []
  (moduleNameToText <$> PE.eiImportedAs ei)

convertExport :: D.DeclarationRef -> Maybe ExternDecl
convertExport (D.ModuleRef mn) = Just (Export (moduleNameToText mn))
convertExport _ = Nothing

convertDecl :: PE.ExternsDeclaration -> Maybe ExternDecl
convertDecl PE.EDType{..} = Just $
  DataDecl
  (properNameToText edTypeName)
  (packAndStrip (PP.prettyPrintKind edTypeKind))
convertDecl PE.EDTypeSynonym{..} = Just $
  DataDecl
  (properNameToText edTypeSynonymName)
  (packAndStrip (PP.prettyPrintType edTypeSynonymType))
convertDecl PE.EDDataConstructor{..} = Just $
  DataDecl
  (properNameToText edDataCtorName)
  (packAndStrip (PP.prettyPrintType edDataCtorType))
convertDecl PE.EDValue{..} = Just $
  FunctionDecl
  (identToText edValueName)
  (packAndStrip (PP.prettyPrintType edValueType))
convertDecl _ = Nothing

packAndStrip :: String -> Text
packAndStrip = T.unwords . fmap T.strip . T.lines . T.pack

unwrapPositioned :: D.Declaration -> D.Declaration
unwrapPositioned (D.PositionedDeclaration _ _ x) = x
unwrapPositioned x = x

unwrapPositionedRef :: D.DeclarationRef -> D.DeclarationRef
unwrapPositionedRef (D.PositionedDeclarationRef _ _ x) = x
unwrapPositionedRef x = x


text:
layout: post
title: "Primeiro post :)"
date: '2015-12-01'
---

Quando fazemos um projeto particular, sabemos que o lance demora pra sair e você ver as idéias funcionando, as vezes até inserimos dados direto no banco por falta de tempo de criar um formulário. Acredito que projetos pessoais são infinitos. Isso mesmo! Não tem fim nunca, pois são com eles que aprendemos coisas novas, sacadas boas pra usar em outros projetos.

Enfim, estou começando esse blog, e vou tentar atualiza-lo com frequencia com coisas úteis sobre desenvolvimento, ele foi feito com [Jekyll][jekyll].

O [Jekyll][jekyll] é um gerador de páginas estáticas, que estou começando a mexer e aprender e ainda pretendo aprender bastante sobre ele. Quem sabe não rola um artigo falando sobre ele mais pra frente. :)

Bom, por enquanto é só, espero colocar algumas coisas nos próximos dias.

[jekyll]:	http://jekyllrb.com


text:
using System.IO;
using System.Reflection;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using Nancy.Demo.TinyBlog.Domain.Converters;

namespace Nancy.Demo.TinyBlog.Tests.Locators
{
    [TestClass]
    public class PostLocatorTests
    {
        [TestMethod]
        public void CanLocatePostsWithinThePostsFolder()
        {
            var resources = Assembly.GetExecutingAssembly().GetManifestResourceNames();
            foreach (var resource in resources)
            {
                var stream = Assembly.GetExecutingAssembly().GetManifestResourceStream(resource);
                if (stream != null)
                {
                    var reader = new StreamReader(stream);
                    var content = reader.ReadToEnd();
                    var deserializer = new PostDeserializer();
                    var instance = deserializer.Serialize(content);
                    Assert.IsTrue(!string.IsNullOrEmpty(instance.Title));
                }
            }
        }
    }
}


text:
/* qgen.h - constructor/parser generator for Q.2931-like data structures */

/* Written 1995-1997 by Werner Almesberger, EPFL-LRC */

#ifndef QGEN_H
#define QGEN_H

typedef enum { vt_id,vt_case,vt_multi,vt_length } VALUE_TYPE;

typedef struct _macro {
    /* --- the following fields are initialized by the parser */
    const char *id;
    struct _field *block;
    int instances; /* this is later modified in the first pass
		      (> 1 becomes -1) */
    struct _macro *next;
    /* --- the following fields are initialized in the first phase */
    int first_field; /* number of the first field in the first instance */
    int fields; /* number of fields covered by this structure */
    int groups; /* number of groups covered by this structure */
} STRUCTURE;

typedef struct _name {
    /* --- the following fields are initialized by the parser */
    const char *value;
    const char *name;
    struct _name *next;
} NAME;

typedef struct _name_list {
    /* --- the following fields are initialized by the parser */
    const char *list_name;
    NAME *list;
    int id; /* initialized to -1 = unassigned */
    struct _name_list *next;
} NAME_LIST;

typedef struct {
    /* --- the following fields are initialized by the parser */
    VALUE_TYPE type;
    const char *recovery; /* only valid if vt_length; NULL if not used */
    const char *abort_id; /* non-NULL to request application-specific error */
    const char *id; /* for value-only and for default tag */
    struct _field *block; /* length */
    struct _tag *tags; /* case or multi */
    /* --- the following fields are initialized in the first phase */
    /* id of default tag */
} VALUE;

typedef struct _field {
    /* --- the following fields are initialized by the parser */
    const char *id;
    NAME_LIST *name_list;
    int size;
    int var_len;
    int pos; /* modified in the first phase */
    int flush;
    VALUE *value;
    int brk; /* != 0: may break before this field */
    struct _field *next;
    STRUCTURE *structure; /* NULL if this entry isn't a structure */
    struct _field *my_block; /* this instance of the structure's body
				(undefined if structure == NULL) */
    /* --- the following fields are initialized in the first phase */
    int field; /* field number */
    int jump; /* move by that many bytes before writing that field */
    int group; /* group number, only in first element of group */
    int seq; /* sequence number - for dumping */
    /* --- the following fields are initialized in the second phase */
    int has_required;
    /* --- the following fields are initialized in the third phase */
    int patch;
} FIELD;

typedef struct _id_list {
    /* --- the following fields are initialized by the parser */
    const char *value;
    struct _id_list *next;
    /* --- the following fields are initialized in the third phase */
    int patch;
} VALUE_LIST;

typedef struct _tag {
    /* --- the following fields are initialized by the parser */
    const char *id; /* group id */
    VALUE_LIST *more; /* only for named selectors */
    const char *value;
    FIELD *block;
    const char *abort_id; /* non-NULL to request application-specific error */
    struct _tag *next;
    int deflt;
    /* --- the following fields are initialized in the first phase */
    int group;
    int pos;
    /* --- the following fields are initialized in the third phase */
    int patch;
} TAG;

void first(FIELD *def);
void second(FIELD *def);
void third(FIELD *def);

#endif


text:
import asyncio
import logging

log = logging.getLogger(__name__)

class TaskBase(object):
    worker_threads_num = 1
    active = False

    async def run(self, task):
        self.active = True
        try:
            return await self._run(task)
        finally:
            self.active = False

    async def _run(self, task):
        raise NotImplementedError

    @staticmethod
    async def _run_command(*args):
        """
        Asynchronous run command in subprocess.

        :param *args: command to execute
        :return: tuple (stdout, stderr, exit code)

        Example from: http://asyncio.readthedocs.io/en/latest/subprocess.html
        """
        # Create subprocess
        log.debug("Executing subprocess: %s", " ".join([a for a in args]))
        # pylint: disable=no-value-for-parameter
        process = await asyncio.create_subprocess_exec(
            *args, stderr=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE)
        # pylint: enable=no-value-for-parameter

        # Status
        log.info('Started: %s (pid = %s)', args, process.pid)

        # Wait for the subprocess to finish
        stdout, stderr = await process.communicate()

        if process.returncode == 0:
            log.debug('Subprocess pid %s succeeded: %s', process.pid, args)
        else:
            log.debug('Subprocess pid %s failed: %s', process.pid, args)

        stdout_str = stdout.decode().strip()
        stderr_str = stderr.decode().strip()

        # Return stdout, stderr, exit code
        return stdout_str, stderr_str, process.returncode


text:
<TITLE>Review for From Here to Eternity (1953)</TITLE>
<LINK REL="STYLESHEET" TYPE="text/css" HREF="/ramr.css">

From Here to Eternity (1953)

reviewed by
Nicholas Amado

>From Here To Eternity
Director: Fred Zinneman
Starring: Montgomery Clift, Burt Lancaster, Donna Reed, Frank Sinatra,
Deborah Kerr, Ernest Borgnine
Running Time: 129 Min
Drama/B&W

The fifties provided some of the greatest films in the history of cinema. New
ideas were developed, new themes explored. Anti and post-war feelings ran
high in Hollywood, and, as a result, films like From Here To Eternity were
made. This Oscar winning picture has ranked among the greatest films ever
made, and with good reason.

>From Here To Eternity takes a hard look at the American Army during World War
II. Corrupt officers, rebellious privates, and an emotionally unstable
Seargent are the focus of this cinematic masterpiece. Mostly, it chronicles a
brief period in the lives of Private Pruit (Clift) and Seargent Warden
(Lancaster), their loves and their sense of duty and honor.

This picture offers filmmaking excellence at every turn. Each main actor
gives the performance of his or her career, particularly Clift, Lancaster,
Sinatra and Reed. (The latter two both won supporting Oscars for thier work
in the film.) Clift is masterful as Pruit, and after viewing this film, (or
re-viewing it, if it has been a while) one cannot imagine anyone else in the
role. He portrays his character with such depth and subtle emotion that a
film about his life prior to where the film picks it up would be thoroughly
engrossing.

Zinneman brings together all the elements of the film brilliantly. His edits
between scenes of Warden and Pruit courting their respective loves are
flawless. In one sequence, he dissolves the crashing waves of one cathartic
episode between Lancaster and Kerr into the rippling smoke of Clift's
cigarette as he opens up for the first time to Donna Reed.

As all the men grow gradually restless on the base, subtle visuals warning of
the attack on Pearl Harbor creep into the frame. Lancaster leans against the
wall while on the telephone, for the first time making us aware of any
time-related element; the calendar shows December 6th. Shortly thereafter, he
moves along a boardwalk , pausing in front of a directional marker, showing,
amongst other things, a sign reading "Pearl Harbor 8m". And on the morning of
the strike, a clock looms in the background, clearly showing ten minutes to
eight, the first bomb hits seconds later. The attack sequence includes
authentic war footage that blends well with the staged action.

This 8 Oscar motion picture helped define the filmmaking of the fifties. It
manages to express anti-war, and in many cases anti-military sentiment while
never allowing us a moment away from a military man. Daniel Taradash won a
well deserved award for his brilliant screenplay. He has each main character
starving for release from what they claim to be their one true love, the
Army. While Warden becomes involved with his superior's wife, Pruit is
falling for a woman who is paid to keep men company in a private club. Each
man picks an emotionally dangerous (and in some respects career-threatening)
situation to break the drudgery of their military lives. The dialogue is
realistic and involving, and each character speaks to us from an emotional
level.

>From Here To Eternity should be viewed by anyone with a respect for fantastic
filmmaking. It begs for a repeat viewing from those who havn't seen it in
ages, and it needs to be seen by anyone who has never had the pleasure.

Four out of Four stars
Copyright (C) 1997 Nick Amado
*************************
Questions? Comments? Complaints? Email me: NAMIAM@AOL.COM

The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).

The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.

Please direct comments/criticisms of the review to relevant newsgroups.

Broken URLs inthe reviews are the responsibility of the author.

The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.

Related links: index of all rec.arts.movies.reviews reviews