@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new ConnectorHandleResolver()
    {
        public Class<? extends ConnectorTableHandle> getTableHandleClass()
        {
            return RestTableHandle.class;
        }

        public Class<? extends ColumnHandle> getColumnHandleClass()
        {
            return RestColumnHandle.class;
        }

        public Class<? extends ConnectorSplit> getSplitClass()
        {
            return RestConnectorSplit.class;
        }

        public Class<? extends ConnectorTableLayoutHandle> getTableLayoutHandleClass()
        {
            return RestConnectorTableLayoutHandle.class;
        }

        @Override
        public Class<? extends ConnectorTransactionHandle> getTransactionHandleClass()
        {
            return RestTransactionHandle.class;
        }

        @Override
        public Class<? extends ConnectorInsertTableHandle> getInsertTableHandleClass()
        {
            return RestInsertTableHandle.class;
        }
    };
}

public void addConnectorName(String name,ConnectorHandleResolver resolver)
{
    requireNonNull(name,"name is null");
    requireNonNull(resolver,"resolver is null");
    ConnectorHandleResolver existingResolver = handleResolvers.putIfAbsent(name,resolver);
    checkState(existingResolver == null || existingResolver.equals(resolver),"Connector '%s' is already assigned to resolver: %s",name,existingResolver);
}

private <T> String getId(T handle,Function<ConnectorHandleResolver,Class<? extends T>> getter)
{
    for (Entry<String,ConnectorHandleResolver> entry : handleResolvers.entrySet()) {
        try {
            if (getter.apply(entry.getValue()).isinstance(handle)) {
                return entry.getKey();
            }
        }
        catch (UnsupportedOperationException ignored) {
        }
    }
    throw new IllegalArgumentException("No connector for handle: " + handle);
}

@Inject
public KafkaConnector(ConnectorMetadata Metadata,ConnectorSplitManager splitManager,ConnectorRecordSetProvider recordSetProvider,ConnectorHandleResolver handleResolver)
{
    construct(Metadata,splitManager,recordSetProvider,handleResolver);
}

private void construct(ConnectorMetadata Metadata,ConnectorHandleResolver handleResolver)
{
      this.Metadata = checkNotNull(Metadata,"Metadata is null");
      this.splitManager = checkNotNull(splitManager,"splitManager is null");
      this.recordSetProvider = checkNotNull(recordSetProvider,"recordSetProvider is null");
      this.handleResolver = checkNotNull(handleResolver,"handleResolver is null");
}

@Override
public Connector create(final String connectorId,Map<String,String> requiredConfig) {
    checkNotNull(requiredConfig,"requiredConfig is null");
    checkNotNull(optionalConfig,"optionalConfig is null");

    try {
        // // A plugin is not required to use Guice; it is just very convenient
        // Bootstrap app = new Bootstrap(new JsonModule(),new ExampleModule(connectorId));
        //
        // Injector injector = app.strictConfig().donotinitializeLogging()
        // .setrequiredConfigurationProperties(requiredConfig)
        // .setoptionalConfigurationProperties(optionalConfig).initialize();

        ClasstoInstanceMap<Object> services = ImmutableClasstoInstanceMap.builder()

        .put(ConnectorMetadata.class,new CloudataConnectorMetadata(connectorId,store))

        .put(ConnectorSplitManager.class,new CloudataSplitManager(nodeManager,connectorId))

        .put(ConnectorRecordSetProvider.class,new CloudataConnectorRecordSetProvider())

        .put(ConnectorHandleResolver.class,new CloudataConnectorHandleResolver()).build();

        CloudataConnector connector = new CloudataConnector(store,services);
        connectors.put(connectorId,connector);
        return connector;
    } catch (Exception e) {
        throw Throwables.propagate(e);
    }
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new HDFSHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver() {
    return new EthereumHandleResolver();
}

public ConnectorHandleResolver getHandleResolver() {
  log.info("informatION: AmpoolConnectorFactory getHandleResolver() called.");
  return new AmpoolHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new KuduHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new KafkaHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new ExampleHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new RaptorHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new RedisHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new BlackHoleHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new TpchIndexHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new JmxHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new JdbcHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new LegacyTransactionHandleResolver(connectorFactory.getHandleResolver());
}

public LegacyTransactionHandleResolver(ConnectorHandleResolver handleResolver)
{
    this.handleResolver = requireNonNull(handleResolver,"handleResolver is null");
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new GlobalSystemHandleResolver();
}

public String getId(ConnectorTableHandle tableHandle)
{
    return getId(tableHandle,ConnectorHandleResolver::getTableHandleClass);
}

public String getId(ConnectorTableLayoutHandle handle)
{
    return getId(handle,ConnectorHandleResolver::getTableLayoutHandleClass);
}

public String getId(ColumnHandle columnHandle)
{
    return getId(columnHandle,ConnectorHandleResolver::getColumnHandleClass);
}

public String getId(ConnectorSplit split)
{
    return getId(split,ConnectorHandleResolver::getSplitClass);
}

public String getId(ConnectorIndexHandle indexHandle)
{
    return getId(indexHandle,ConnectorHandleResolver::getIndexHandleClass);
}

public String getId(ConnectorOutputTableHandle outputHandle)
{
    return getId(outputHandle,ConnectorHandleResolver::getoutputTableHandleClass);
}

public String getId(ConnectorInsertTableHandle insertHandle)
{
    return getId(insertHandle,ConnectorHandleResolver::getInsertTableHandleClass);
}

public String getId(ConnectorTransactionHandle transactionHandle)
{
    return getId(transactionHandle,ConnectorHandleResolver::getTransactionHandleClass);
}

public ConnectorHandleResolver resolverFor(String id)
{
    ConnectorHandleResolver resolver = handleResolvers.get(id);
    checkArgument(resolver != null,"No handle resolver for connector: %s",id);
    return resolver;
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new TpchHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new TpchHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new CassandraHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new HiveHandleResolver();
}

@Override
public ConnectorHandleResolver getHandleResolver() {
  return _handleResolver;
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new KinesisHandleResolver(connectorName);
}

@Override
    public Connector create(String connectorId,String> config)
    {
        checkNotNull(config,"config is null");

        try {
            KafkaClientModule kafkaClientModule = new KafkaClientModule(connectorId);

            Bootstrap app = new Bootstrap(
                    new NodeModule(),new JsonModule(),kafkaClientModule
                );

            Injector injector = app.strictConfig().donotinitializeLogging()
                    .setrequiredConfigurationProperties(config)
                    .quiet()
                    .requireExplicitBindings(false)
                    .setoptionalConfigurationProperties(optionalConfig).initialize();

            KafkaClientConfig clientConfig = KafkaClientConfig.INSTANCE;
            KafkaPluginConfig pluginConfig = KafkaPluginConfig.INSTANCE;
            KafkaConnectorId kafkaConnectorId = KafkaConnectorId.INSTANCE;
            KafkaHiveClient hiveClient = new KafkaHiveClient(kafkaConnectorId,clientConfig,pluginConfig);
            KafkaMetadata kafkaMetadata = new KafkaMetadata(hiveClient,kafkaConnectorId);
            KafkaSplitManager kafkaSplitManager = new KafkaSplitManager(hiveClient,kafkaConnectorId,clientConfig);
            KafkaRecordSetProvider kafkaRecordSetProvider = new KafkaRecordSetProvider(kafkaConnectorId);
            KafkaHandleResolver kafkaHandleResolver = new KafkaHandleResolver(kafkaConnectorId);

            ConnectorMetadata connMetadata = new ClassLoaderSafeConnectorMetadata(kafkaMetadata,classLoader);
            ConnectorSplitManager connSplitManager = new ClassLoaderSafeConnectorSplitManager(kafkaSplitManager,classLoader);
            ConnectorRecordSetProvider connRecordSetProvider = new ClassLoaderSafeConnectorRecordSetProvider(kafkaRecordSetProvider,classLoader);
            ConnectorHandleResolver connHandleResolver = new ClassLoaderSafeConnectorHandleResolver(kafkaHandleResolver,classLoader);

            return new KafkaConnector(connMetadata,connSplitManager,connRecordSetProvider,connHandleResolver);

//            return injector.getInstance(KafkaConnector.class);

//            KafkaMetadata kafkaMetadata = injector.getInstance(KafkaMetadata.class);
//            KafkaSplitManager kafkaSplitManager = injector.getInstance(KafkaSplitManager.class);
//            KafkaRecordSetProvider kafkaRecordSetProvider = injector.getInstance(KafkaRecordSetProvider.class);
//            KafkaHandleResolver kafkaHandleResolver = injector.getInstance(KafkaHandleResolver.class);
//            return new KafkaConnector(kafkaMetadata,kafkaSplitManager,//                kafkaRecordSetProvider,kafkaHandleResolver);
//            return new KafkaConnector(
//                    new ClassLoaderSafeConnectorMetadata(kafkaMetadata,classLoader),//                    new ClassLoaderSafeConnectorSplitManager(kafkaSplitManager,//                    new ClassLoaderSafeConnectorRecordSetProvider(kafkaRecordSetProvider,//                    new ClassLoaderSafeConnectorHandleResolver(kafkaHandleResolver,classLoader));
        } catch (Exception e) {
            e.printstacktrace();
            throw Throwables.propagate(e);
        }
    }

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return handleResolver;
}

ConnectorHandleResolver getHandleResolver();

@Test
public void coercingSourcePathsSetsNames()
    throws NoSuchFieldException,CoerceFailedException {
  buildruleResolver buildruleResolver = new buildruleResolver();
  FakeProjectFilesystem filesystem = new FakeProjectFilesystem();

  PathTypeCoercer pathTypeCoercer = new PathTypeCoercer();
  BuildtargettypeCoercer buildtargettypeCoercer = new BuildtargettypeCoercer();
  SourcePathTypeCoercer sourcePathTypeCoercer =
      new SourcePathTypeCoercer(buildtargettypeCoercer,pathTypeCoercer);

  Path basePath = Paths.get("base");

  // Verify that regular strings coerced as PathSourcePaths preserve their original name.
  String src = "test/source.cpp";
  SourcePath res = sourcePathTypeCoercer.coerce(
      buildruleResolver,filesystem,basePath,src);
  assertEquals(res.getName(),src);
}

/**
 * @return a set of {@link CxxCompile} rules preprocessing,compiling,and assembling the
 *    given input {@link CxxSource} sources.
 */
public static ImmutableSortedSet<buildrule> createCompilebuildrules(
    buildruleParams params,buildruleResolver resolver,Path compiler,CxxPreprocessorInput preprocessorInput,ImmutableList<String> compilerFlags,Iterable<CxxSource> sources) {

  ImmutableSortedSet.Builder<buildrule> rules = ImmutableSortedSet.naturalOrder();

  // Iterate over the input C/C++ sources that we need to preprocess,assemble,and compile,// and generate compile rules for them.
  for (CxxSource source : sources) {
    rules.add(createCompilebuildrule(
        params,resolver,compiler,preprocessorInput,compilerFlags,source));
  }

  return rules.build();
}

@Override
public void registerFlavors(
    Arg arg,buildrule buildrule,ProjectFilesystem projectFilesystem,RuleKeyBuilderFactory ruleKeyBuilderFactory,buildruleResolver ruleResolver) {
  BuildTarget prebuiltJarBuildTarget = buildrule.getBuildTarget();
  BuildTarget flavoredBuildTarget = BuildTargets.createFlavoredBuildTarget(
      prebuiltJarBuildTarget,JavaLibrary.GWT_MODULE_FLAVOR);
  buildruleParams params = new buildruleParams(
      flavoredBuildTarget,/* declaredDeps */ ImmutableSortedSet.of(buildrule),/* inferredDeps */ ImmutableSortedSet.<buildrule>of(),BuildTargetPattern.PUBLIC,projectFilesystem,ruleKeyBuilderFactory,buildruleType.GWT_MODULE);
  buildrule gwtModule = createGwtModule(params,arg);
  ruleResolver.addToIndex(gwtModule.getBuildTarget(),gwtModule);
}

protected void fillSortedSet(
    buildruleResolver buildruleResolver,ProjectFilesystem filesystem,Path pathRelativetoProjectRoot,SortedSet<T> builder,Object object) throws CoerceFailedException {

  if (object instanceof Collection) {
    for (Object element : (Iterable<?>) object) {
      // if any element Failed,the entire collection fails
      T coercedElement = elementTypeCoercer.coerce(
          buildruleResolver,pathRelativetoProjectRoot,element);
      boolean alreadyExists = !builder.add(coercedElement);
      if (alreadyExists) {
        throw new CoerceFailedException(
            String.format("duplicate element \"%s\"",coercedElement));
      }
    }
  } else {
    throw CoerceFailedException.simple(object,getoutputClass());
  }
}

@Test
public void testDepsgenrule() {
  buildruleResolver ruleResolver = new buildruleResolver();
  buildrule javaBinary = createSampleJavaBinaryRule(ruleResolver);

  // Interpolate the build target in the genrule cmd string.
  String originalCmd = "$(exe :ManifestGenerator) $OUT";
  Set<? extends buildrule> deps = ImmutableSet.of(javaBinary);
  Path contextBasePath = Paths.get("java/com/facebook/util");

  Genrule rule = (Genrule) createGenrule(ruleResolver,originalCmd,contextBasePath,deps);
  AbstractGenruleStep genruleStep = rule.createGenruleStep();

  String transformedString = genruleStep.replaceMatches(fakeFilesystem,originalCmd);

  // Verify that the correct cmd was created.
  Path expectedClasspath = getAbsolutePathInBase(
      GEN_DIR + "/java/com/facebook/util/ManifestGenerator.jar");
  String expectedCmd = String.format(
      "java -jar %s $OUT",expectedClasspath);
  assertEquals(expectedCmd,transformedString);
}

@Test
public void replaceLocationOfFullyQualifiedBuildTarget() throws IOException {
  ProjectFilesystem filesystem = new FakeProjectFilesystem();

  buildruleResolver ruleResolver = new buildruleResolver();
  buildrule javaBinary = createSampleJavaBinaryRule(ruleResolver);
  Path outputPath = javaBinary.getPathToOutputFile();
  Path absolutePath = outputPath.toAbsolutePath();

  String originalCmd = String.format("$(location :%s) $(location %s) $OUT",javaBinary.getBuildTarget().getShortName(),javaBinary.getBuildTarget().getFullyQualifiedname());

  Path contextBasePath = javaBinary.getBuildTarget().getBasePath();
  Set<? extends buildrule> deps = ImmutableSet.of(javaBinary);

  Genrule buildable = (Genrule) createGenrule(ruleResolver,deps);
  AbstractGenruleStep genruleStep = buildable.createGenruleStep();

  // Interpolate the build target in the genrule cmd string.
  String transformedString = genruleStep.replaceMatches(filesystem,originalCmd);

  // Verify that the correct cmd was created.
  String expectedCmd = String.format("%s %s $OUT",absolutePath,absolutePath);
  assertEquals(expectedCmd,transformedString);
}

public Genrule build() {
  final ImmutableSortedSet<buildrule> depRules = ImmutableSortedSet.copyOf(deps);
  args.deps = Optional.of(depRules);
  args.srcs = Optional.of(FluentIterable
      .from(srcs.build())
      .transform(SourcePaths.TO_SOURCE_PATH)
      .toList());

  buildruleParams params = new FakebuildruleParamsBuilder(target)
      .setDeps(depRules)
      .setType(GenruleDescription.TYPE)
      .setProjectFilesystem(
          new ProjectFilesystem(Paths.get(".")) {
            @Override
            public Function<Path,Path> getAbsolutifier() {
              return Optional.fromNullable(absolutifier)
                  .or(IdentityPathAbsolutifier.getIdentityAbsolutifier());
            }
          })
      .build();
  return description.createbuildrule(params,new buildruleResolver(),args);
}

@Test
public void testReplaceRelativeBinarybuildruleRefsInCmd() {
  buildruleResolver ruleResolver = new buildruleResolver();
  buildrule javaBinary = createSampleJavaBinaryRule(ruleResolver);

  String originalCmd = "$(exe :ManifestGenerator) $OUT";
  Path contextBasePath = Paths.get("java/com/facebook/util");
  Set<? extends buildrule> deps = ImmutableSet.of(javaBinary);

  Genrule buildable = (Genrule) createGenrule(ruleResolver,deps);
  AbstractGenruleStep genruleStep = buildable.createGenruleStep();

  // Interpolate the build target in the genrule cmd string.
  String transformedString = genruleStep.replaceMatches(fakeFilesystem,transformedString);
}

@Override
public ImmutableMap<K,V> coerce(
    buildruleResolver buildruleResolver,Object object)
    throws CoerceFailedException {
  if (object instanceof Map) {
    ImmutableMap.Builder<K,V> builder = ImmutableMap.builder();

    for (Map.Entry<?,?> entry : ((Map<?,?>) object).entrySet()) {
      K key = keyTypeCoercer.coerce(
          buildruleResolver,entry.getKey());
      V value = valueTypeCoercer.coerce(
          buildruleResolver,entry.getValue());
      builder.put(key,value);
    }

    return builder.build();
  } else {
    throw CoerceFailedException.simple(object,getoutputClass());
  }
}

@Test
public void testJsonClasspathOutput() throws IOException {
  // Build a DependencyGraph of build rules manually.
  buildruleResolver ruleResolver = new buildruleResolver();
  ImmutableList<String> targets = ImmutableList.of(
      "//:test-android-library","//:test-java-library");

  buildrule library = JavaLibraryBuilder
      .createBuilder(BuildTargetFactory.newInstance("//:test-java-library"))
      .addSrc(Paths.get("src/com/facebook/TestJavaLibrary.java"))
      .build(ruleResolver);
  AndroidLibraryBuilder.createBuilder(BuildTargetFactory.newInstance("//:test-android-library"))
      .addSrc(Paths.get("src/com/facebook/TestAndroidLibrary.java"))
      .addDep(library)
      .build(ruleResolver);

  PartialGraph partialGraph = createGraphFrombuildrules(ruleResolver,targets);
  auditClasspathCommand.printJsonClasspath(partialGraph);

  assertEquals(EXPECTED_JSON,console.getTextWrittenToStdOut());
  assertEquals("",console.getTextWrittenToStdErr());
}

@Override
public <A extends Args> PrebuiltNativeLibrary createbuildrule(
    buildruleParams params,A args) {
  ImmutableSortedSet<Path> librarySources;
  try {
    librarySources = ImmutableSortedSet.copyOf(
        params.getProjectFilesystem().getFilesUnderPath(args.nativeLibs));
  } catch (IOException e) {
    throw new HumanReadableException(e,"Error traversing directory %s.",args.nativeLibs);
  }

  return new PrebuiltNativeLibrary(
      params,args.nativeLibs,args.isAsset.or(false),librarySources
  );
}

private void createSampleAndroidBinaryRule(buildruleResolver ruleResolver) {
  // Create a java_binary that depends on a java_library so it is possible to create a
  // java_binary rule with a classpath entry and a main class.
  BuildTarget libAndroidTarget = BuildTargetFactory.newInstance("//:lib-android");
  buildrule androidLibRule = JavaLibraryBuilder.createBuilder(libAndroidTarget)
      .addSrc(Paths.get("java/com/facebook/util/Facebook.java"))
      .build(ruleResolver);

  BuildTarget keystoreTarget = BuildTargetFactory.newInstance("//keystore:debug");
  Keystore keystore = (Keystore) KeystoreBuilder.createBuilder(keystoreTarget)
      .setStore(Paths.get("keystore/debug.keystore"))
      .setProperties(Paths.get("keystore/debug.keystore.properties"))
      .build(ruleResolver);

  AndroidBinaryBuilder.createBuilder(BuildTargetFactory.newInstance("//:fb4a"))
      .setManifest(new TestSourcePath("AndroidManifest.xml"))
      .setTarget("Google Inc.:Google Apis:16")
      .setoriginalDeps(ImmutableSortedSet.of(androidLibRule))
      .setKeystore(keystore)
      .build(ruleResolver);
}

@Test
public void testGetInputsToComparetoOuts() {
  buildruleResolver ruleResolver = new buildruleResolver();
  buildrule androidLibraryBuilderBar = getAndroidLibraryRuleBar(ruleResolver);
  buildrule androidLibraryBuilderFoo = getAndroidLibraryRuleFoo(ruleResolver);
  BuildContext context = createMock(BuildContext.class);
  replay(context);

  MoreAsserts.assertIterablesEquals(
      "getInputsToComparetoOutput() should include manifest and src.",ImmutableList.of(
          Paths.get("java/src/com/foo/Foo.java"),Paths.get("java/src/com/foo/AndroidManifest.xml")),androidLibraryBuilderFoo.getInputs());

  MoreAsserts.assertIterablesEquals(
      "getInputsToComparetoOutput() should include only src.",ImmutableList.of(Paths.get("java/src/com/bar/Bar.java")),androidLibraryBuilderBar.getInputs());

  assertEquals(
      "foo's exported deps should include bar",ImmutableSet.of(androidLibraryBuilderBar),((AndroidLibrary) (androidLibraryBuilderFoo)).getExportedDeps());
}

@Test
public void testJavaLibaryThrowsIfResourceIsDirectory() {
  ProjectFilesystem filesystem = new AllExistingProjectFilesystem() {
    @Override
    public boolean isDirectory(Path path,LinkOption... linkOptionsk) {
      return true;
    }
  };

  try {
    JavaLibraryBuilder
        .createBuilder(BuildTargetFactory.newInstance("//library:code"))
        .addResource(new TestSourcePath("library"))
        .build(new buildruleResolver(),filesystem);
    fail("An exception should have been thrown because a directory was passed as a resource.");
  } catch (HumanReadableException e) {
    assertTrue(e.getHumanReadableErrorMessage().contains("a directory is not a valid input"));
  }
}

@Test
public void testGetUnsignedApkPath() {
  buildruleResolver ruleResolver = new buildruleResolver();
  Keystore keystore = (Keystore) addKeystoreRule(ruleResolver);

  AndroidBinary ruleInRootDirectory = (AndroidBinary) AndroidBinaryBuilder.createBuilder(
      BuildTargetFactory.newInstance("//:fb4a"))
      .setManifest(new TestSourcePath("AndroidManifest.xml"))
      .setKeystore(keystore)
      .setTarget("Google Inc.:Google Apis:16")
      .build(ruleResolver);
  assertEquals(Paths.get(GEN_DIR + "/fb4a.apk"),ruleInRootDirectory.getApkPath());

  AndroidBinary ruleInNonRootDirectory = (AndroidBinary) AndroidBinaryBuilder.createBuilder(
      BuildTargetFactory.newInstance("//java/com/example:fb4a"))
      .setManifest(new TestSourcePath("AndroidManifest.xml"))
      .setKeystore(keystore)
      .setTarget("Google Inc.:Google Apis:16")
      .build(ruleResolver);
  assertEquals(
      Paths.get(GEN_DIR + "/java/com/example/fb4a.apk"),ruleInNonRootDirectory.getApkPath());
}

@Test
public void testemptySuggestBuildFunction() {
  buildruleResolver ruleResolver = new buildruleResolver();

  BuildTarget libraryOneTarget = BuildTargetFactory.newInstance("//:libone");
  JavaLibrary libraryOne = (JavaLibrary) JavaLibraryBuilder
      .createBuilder(libraryOneTarget)
      .addSrc(Paths.get("java/src/com/libone/bar.java"))
      .build();

  BuildContext context = createSuggestContext(ruleResolver,BuildDependencies.FirsT_ORDER_ONLY);

  ImmutableSetMultimap<JavaLibrary,Path> classpathEntries =
      libraryOne.getTransitiveClasspathEntries();

  assertEquals(
      Optional.<JavacInMemoryStep.Suggestbuildrules>absent(),((DefaultJavaLibrary) libraryOne).createSuggestBuildFunction(
          context,classpathEntries,createJarResolver(/* classtoSymbols */ImmutableMap.<Path,String>of())));

  EasyMock.verify(context);
}

@Test
public void thatMainSourcePathPropagatesToDeps() {
  buildruleResolver resolver = new buildruleResolver();

  Genrule genrule = GenruleBuilder.createGenrule(BuildTargetFactory.newInstance("//:gen"))
      .setout("blah.py")
      .build();
  buildruleParams params = buildruleParamsFactory.createTrivialbuildruleParams(
      BuildTargetFactory.newInstance("//:bin"));
  PythonBinaryDescription desc = new PythonBinaryDescription(PEX_PATH);
  PythonBinaryDescription.Arg arg = desc.createUnpopulatedConstructorArg();
  arg.deps = Optional.of(ImmutableSortedSet.<buildrule>of());
  arg.main = new buildruleSourcePath(genrule);
  buildrule rule = desc.createbuildrule(params,arg);
  assertEquals(
      ImmutableSortedSet.<buildrule>of(genrule),rule.getDeps());
}

@Test
public void thatTestModulesAreInComponents() {
  buildruleResolver resolver = new buildruleResolver();
  buildruleParams params =
      new FakebuildruleParamsBuilder(BuildTargetFactory.newInstance("//:bin"))
          .build();
  PythonTestDescription desc = new PythonTestDescription(PEX_PATH,TEST_MAIN);
  PythonTestDescription.Arg arg = desc.createUnpopulatedConstructorArg();
  arg.deps = Optional.of(ImmutableSortedSet.<buildrule>of());
  arg.srcs = Optional.of(ImmutableSortedSet.<SourcePath>of(new TestSourcePath("blah.py")));
  arg.resources = Optional.absent();
  arg.contacts = Optional.absent();
  arg.labels = Optional.absent();
  arg.sourceUnderTest = Optional.absent();
  PythonTest testRule = desc.createbuildrule(params,arg);

  PythonBinary binRule = (PythonBinary) resolver.get(
      desc.getBinaryBuildTarget(testRule.getBuildTarget()));
  assertNotNull(binRule);

  PythonPackageComponents components = binRule.getComponents();
  assertTrue(components.getModules().containsKey(desc.getTestModulesListName()));
  assertTrue(components.getModules().containsKey(desc.getTestMainName()));
  assertEquals(binRule.getMain(),desc.getTestMainName());
}

@Test
public void getInputsToComparetoOutput() {
  AppleNativeTargetDescriptionArg arg = description.createUnpopulatedConstructorArg();
  arg.srcs = ImmutableList.of(
      AppleSource.ofSourcePath(new TestSourcePath("some_source.m")),AppleSource.ofSourcePath(new TestSourcePath("some_header.h")));
  arg.configs = ImmutableMap.of();
  arg.frameworks = ImmutableSortedSet.of();
  arg.deps = Optional.absent();
  arg.gid = Optional.absent();
  arg.headerPathPrefix = Optional.absent();
  arg.useBuckHeaderMaps = Optional.absent();

  buildruleParams params =
      new FakebuildruleParamsBuilder(BuildTarget.builder("//foo","foo").build()).build();
  AppleLibrary buildable = description.createbuildrule(params,arg);

  assertthat(buildable.getInputsToComparetoOutput(),containsInAnyOrder(
      Paths.get("some_header.h"),Paths.get("some_source.m")));
}

@Test
public void getDynamicFlavorOutputName() {
  AppleNativeTargetDescriptionArg arg = description.createUnpopulatedConstructorArg();
  arg.srcs = ImmutableList.of();
  arg.configs = ImmutableMap.of();
  arg.frameworks = ImmutableSortedSet.of();
  arg.deps = Optional.absent();
  arg.gid = Optional.absent();
  arg.headerPathPrefix = Optional.absent();
  arg.useBuckHeaderMaps = Optional.absent();

  BuildTarget target = BuildTarget.builder("//foo","foo")
      .setFlavor(AppleLibraryDescription.DYNAMIC_LIBRARY)
      .build();
  buildruleParams params = new FakebuildruleParamsBuilder(target).build();
  AppleLibrary buildable = description.createbuildrule(params,arg);

  assertEquals(Paths.get("buck-out/bin/foo/#dynamic/foo.dylib"),buildable.getPathToOutputFile());
}

@Override
public <A extends Args> JavaBinary createbuildrule(
    buildruleParams params,A args) {
  return new JavaBinary(
      params,args.mainClass.orNull(),args.manifestFile.orNull(),args.mergeManifests.or(true),args.MetaInfDirectory.orNull(),args.blacklist.or(ImmutableSortedSet.<String>of()),new DefaultDirectoryTraverser());
}

public static ImmutableSet<buildrule> validateAndGetSourcesUnderTest(
    ImmutableSet<BuildTarget> sourceUnderTestTargets,BuildTarget owner,buildruleResolver resolver) {
  ImmutableSet.Builder<buildrule> sourceUnderTest = ImmutableSet.builder();
  for (BuildTarget target : sourceUnderTestTargets) {
    buildrule rule = resolver.get(target);
    if (rule == null) {
      throw new HumanReadableException(
          "Specified source under test for %s is not among its dependencies: %s",owner,target);
    }
    if (!(rule instanceof JavaLibrary)) {
      // In this case,the source under test specified in the build file was not a Java library
      // rule. Since emmA requires the sources to be in Java,we will throw this exception and
      // not continue with the tests.
      throw new HumanReadableException(
          "Specified source under test for %s is not a Java library: %s (%s).",rule.getFullyQualifiedname(),rule.getType().getName());
    }
    sourceUnderTest.add(rule);
  }
  return sourceUnderTest.build();
}

@Override
public <A extends Arg> buildrule createbuildrule(
    buildruleParams params,A args) {
  return new PrebuiltJar(
      params,args.binaryJar,args.sourceJar,args.gwtJar,args.javadocUrl);
}

@Override
public <A extends Arg> Keystore createbuildrule(
    buildruleParams params,A args) {
  return new Keystore(params,args.store,args.properties);
}

@Override
public <A extends Arg> GenParcelable createbuildrule(
    buildruleParams params,A args) {
  return new GenParcelable(params,args.srcs);
}

private PartialGraph createGraphFrombuildrules(buildruleResolver ruleResolver,List<String> targets) {
  ImmutableSet<BuildTarget> buildTargets = ImmutableSet.copyOf(
      Iterables.transform(
          targets,new Function<String,BuildTarget>() {
            @Override
            public BuildTarget apply(String target) {
              return BuildTargetFactory.newInstance(target);
            }
          }));

  ActionGraph actionGraph = RuleMap.createGraphFrombuildrules(ruleResolver);
  return PartialGraphFactory.newInstance(actionGraph,buildTargets);
}

@Test
public void testDexingCommand() {
  buildruleResolver ruleResolver = new buildruleResolver();
  AndroidBinary splitDexRule = (AndroidBinary) AndroidBinaryBuilder.createBuilder(
      BuildTargetFactory.newInstance("//:fbandroid_with_dash_debug_fbsign"))
      .setManifest(new TestSourcePath("AndroidManifest.xml"))
      .setKeystore((Keystore) addKeystoreRule(ruleResolver))
      .setTarget("Google Inc.:Google Apis:16")
      .setShouldSplitDex(true)
      .setLinearallocHardLimit(0)
      .setPrimaryDexScenarioOverflowAllowed(true)
      .setDexCompression(DexStore.JAR)
      .build(ruleResolver);

  Set<Path> classpath = Sets.newHashSet();
  ImmutableSet.Builder<Path> secondaryDexDirectories = ImmutableSet.builder();
  ImmutableList.Builder<Step> commandsBuilder = ImmutableList.builder();
  Path primaryDexPath = BIN_PATH.resolve(".dex/classes.dex");
  splitDexRule.addDexingSteps(
      classpath,suppliers.<Map<String,HashCode>>ofInstance(ImmutableMap.<String,HashCode>of()),secondaryDexDirectories,commandsBuilder,primaryDexPath);

  assertEquals("Expected 2 new assets paths (one for Metadata.txt and the other for the " +
      "secondary zips)",2,secondaryDexDirectories.build().size());

  List<Step> steps = commandsBuilder.build();
  assertCommandsInorder(steps,ImmutableList.<Class<?>>of(SplitZipStep.class,SmartDexingStep.class));
}

@Override
public <A extends Arg> AppleTest createbuildrule(
    buildruleParams params,A args) {
  return new AppleTest(params,args);
}

@Override
public <A extends Arg> AppleAssetCatalog createbuildrule(
    buildruleParams params,A args) {
  ProjectFilesystem projectFilesystem = params.getProjectFilesystem();
  supplier<ImmutableCollection<Path>> inputPathssupplier =
      RuleUtils.subpathsOfPathssupplier(projectFilesystem,args.dirs);
  return new AppleAssetCatalog(params,inputPathssupplier,args);
}

@Override
public <A extends AppleNativeTargetDescriptionArg> AppleLibrary createbuildrule(
    buildruleParams params,A args) {
  return new AppleLibrary(
      params,args,TargetSources.ofAppleSources(args.srcs),archiver,params.getBuildTarget().getFlavor().equals(DYNAMIC_LIBRARY));
}

@Override
public <A extends Arg> XcodeWorkspaceConfig createbuildrule(
    buildruleParams params,A args) {
  return new XcodeWorkspaceConfig(params,args);
}

@Test
public void targetGidindescriptionSetsTargetGidInGeneratedProject() throws IOException {
  buildruleParams params =
      new FakebuildruleParamsBuilder(BuildTarget.builder("//foo","lib").build())
          .setType(AppleLibraryDescription.TYPE)
          .build();
  AppleNativeTargetDescriptionArg arg = appleLibraryDescription.createUnpopulatedConstructorArg();
  arg.configs = ImmutableMap.of();
  arg.srcs = ImmutableList.of();
  arg.frameworks = ImmutableSortedSet.of();
  arg.deps = Optional.absent();
  arg.gid = Optional.of("D00D64738");
  arg.headerPathPrefix = Optional.absent();
  arg.useBuckHeaderMaps = Optional.absent();

  buildrule rule = appleLibraryDescription.createbuildrule(params,arg);

  ProjectGenerator projectGenerator = createProjectGeneratorForCombinedProject(
      ImmutableSet.of(rule),ImmutableSet.of(rule.getBuildTarget()));

  projectGenerator.createXcodeProjects();

  PBXTarget target = assertTargetExistsAndReturnTarget(
      projectGenerator.getGeneratedProject(),"//foo:lib");
  // Ensure the GID for the target uses the gid value in the description.
  assertthat(target.getGlobalID(),equalTo("D00D64738"));
}

@Override
public <A extends Arg> XcodeProjectConfig createbuildrule(
    buildruleParams params,A args) {
  return new XcodeProjectConfig(params,args);
}

@Override
public <A extends Arg> CoreDataModel createbuildrule(
    buildruleParams params,A args) {
  ProjectFilesystem projectFilesystem = params.getProjectFilesystem();
  supplier<ImmutableCollection<Path>> inputPathssupplier = RuleUtils.subpathsOfPathssupplier(
      projectFilesystem,ImmutableSet.of(args.path));
  return new CoreDataModel(params,args);
}

@Override
public <A extends Arg> AppleBundle createbuildrule(
    buildruleParams params,A args) {
  return new AppleBundle(params,args);
}

@Override
public buildrule coerce(
    buildruleResolver buildruleResolver,Object object)
    throws CoerceFailedException {
  try {
    BuildTarget buildTarget = buildtargettypeCoercer.coerce(
        buildruleResolver,object);
    return buildruleResolver.get(buildTarget);
  } catch (CoerceFailedException e) {
    throw CoerceFailedException.simple(object,getoutputClass());
  }
}

@Override
public ImmutableSortedSet<T> coerce(
    buildruleResolver buildruleResolver,Object object)
    throws CoerceFailedException {
  final SortedSet<T> builder = Sets.newTreeSet();
  fillSortedSet(buildruleResolver,builder,object);
  return ImmutableSortedSet.copyOf(builder);
}

@Override
public T coerce(
    buildruleResolver buildruleResolver,Object object)
    throws CoerceFailedException {
  if (type.isAssignableFrom(object.getClass())) {
    return type.cast(object);
  }
  throw CoerceFailedException.simple(object,getoutputClass());
}

@Override
public ImmutableList<T> coerce(
    buildruleResolver buildruleResolver,Object object) throws CoerceFailedException {
  ImmutableList.Builder<T> builder = ImmutableList.builder();
  fill(buildruleResolver,object);
  return builder.build();
}

@Override
public Label coerce(
    buildruleResolver buildruleResolver,Object object) throws CoerceFailedException {
  if (object instanceof String) {
    return new Label((String) object);
  }
  throw CoerceFailedException.simple(object,getoutputClass());
}

@Test
public void testWidthAndHeightWithRotatedImage() {
  // Reverse width and height as the rotation angle should put them back again
  mBitmap = Bitmap.createBitmap(HEIGHT,WIDTH,Bitmap.Config.ARGB_8888);
  ResourceReleaser<Bitmap> releaser = SimpleBitmapReleaser.getInstance();
  mCloseableStaticBitmap =
      new CloseableStaticBitmap(
          mBitmap,releaser,ImmutableQualityInfo.FULL_QUALITY,90,ExifInterface.ORIENTATION_ROTATE_90);

  assertthat(mCloseableStaticBitmap.getWidth()).isEqualTo(WIDTH);
  assertthat(mCloseableStaticBitmap.getHeight()).isEqualTo(HEIGHT);
}

@Test
public void testWidthAndHeightWithInvertedOrientationImage() {
  // Reverse width and height as the inverted orienvation should put them back again
  mBitmap = Bitmap.createBitmap(HEIGHT,ExifInterface.ORIENTATION_TRANSPOSE);

  assertthat(mCloseableStaticBitmap.getWidth()).isEqualTo(WIDTH);
  assertthat(mCloseableStaticBitmap.getHeight()).isEqualTo(HEIGHT);
}

public BitmapCounter(int maxCount,int maxSize) {
  Preconditions.checkArgument(maxCount > 0);
  Preconditions.checkArgument(maxSize > 0);
  mMaxCount = maxCount;
  mMaxSize = maxSize;
  mUnpooledBitmapsReleaser = new ResourceReleaser<Bitmap>() {
    @Override
    public void release(Bitmap value) {
      try {
        decrease(value);
      } finally {
        value.recycle();
      }
    }
  };
}

public SharedByteArray(
    MemoryTrimmableRegistry memoryTrimmableRegistry,PoolParams params) {
  Preconditions.checkNotNull(memoryTrimmableRegistry);
  Preconditions.checkArgument(params.minBucketSize > 0);
  Preconditions.checkArgument(params.maxBucketSize >= params.minBucketSize);

  mMaxByteArraySize = params.maxBucketSize;
  mMinByteArraySize = params.minBucketSize;
  mByteArraySoftRef = new OOMSoftReference<byte[]>();
  mSemaphore = new Semaphore(1);
  mResourceReleaser = new ResourceReleaser<byte[]>() {
    @Override
    public void release(byte[] unused) {
      mSemaphore.release();
    }
  };

  memoryTrimmableRegistry.registerMemoryTrimmable(this);
}

@Test
public void testWidthAndHeightWithRotatedImage() {
  // Reverse width and height as the rotation angle should put them back again
  mBitmap = Bitmap.createBitmap(HEIGHT,ExifInterface.ORIENTATION_ROTATE_90);

  assertthat(mCloseableStaticBitmap.getWidth()).isEqualTo(WIDTH);
  assertthat(mCloseableStaticBitmap.getHeight()).isEqualTo(HEIGHT);
}

@Test
public void testWidthAndHeightWithInvertedOrientationImage() {
  // Reverse width and height as the inverted orienvation should put them back again
  mBitmap = Bitmap.createBitmap(HEIGHT,ExifInterface.ORIENTATION_TRANSPOSE);

  assertthat(mCloseableStaticBitmap.getWidth()).isEqualTo(WIDTH);
  assertthat(mCloseableStaticBitmap.getHeight()).isEqualTo(HEIGHT);
}

public BitmapCounter(int maxCount,int maxSize) {
  Preconditions.checkArgument(maxCount > 0);
  Preconditions.checkArgument(maxSize > 0);
  mMaxCount = maxCount;
  mMaxSize = maxSize;
  mUnpooledBitmapsReleaser = new ResourceReleaser<Bitmap>() {
    @Override
    public void release(Bitmap value) {
      try {
        decrease(value);
      } finally {
        value.recycle();
      }
    }
  };
}

public SharedByteArray(
    MemoryTrimmableRegistry memoryTrimmableRegistry,PoolParams params) {
  Preconditions.checkNotNull(memoryTrimmableRegistry);
  Preconditions.checkArgument(params.minBucketSize > 0);
  Preconditions.checkArgument(params.maxBucketSize >= params.minBucketSize);

  mMaxByteArraySize = params.maxBucketSize;
  mMinByteArraySize = params.minBucketSize;
  mByteArraySoftRef = new OOMSoftReference<byte[]>();
  mSemaphore = new Semaphore(1);
  mResourceReleaser = new ResourceReleaser<byte[]>() {
    @Override
    public void release(byte[] unused) {
      mSemaphore.release();
    }
  };

  memoryTrimmableRegistry.registerMemoryTrimmable(this);
}

public PooledByteArrayBufferedInputStream(
    InputStream inputStream,byte[] byteArray,ResourceReleaser<byte[]> resourceReleaser) {
  mInputStream = Preconditions.checkNotNull(inputStream);
  mByteArray = Preconditions.checkNotNull(byteArray);
  mResourceReleaser = Preconditions.checkNotNull(resourceReleaser);
  mBufferedSize = 0;
  mBufferOffset = 0;
  mClosed = false;
}

/** Creates a new reference for the client. */
private synchronized CloseableReference<V> newClientReference(final Entry<K,V> entry) {
  increaseClientCount(entry);
  return CloseableReference.of(
      entry.valueRef.get(),new ResourceReleaser<V>() {
        @Override
        public void release(V unused) {
          releaseClientReference(entry);
        }
      });
}

/**
 * Creates a new instance of a CloseableStaticBitmap.
 *
 * @param bitmap the bitmap to wrap
 * @param resourceReleaser ResourceReleaser to release the bitmap to
 */
public CloseableStaticBitmap(
    Bitmap bitmap,ResourceReleaser<Bitmap> resourceReleaser,QualityInfo qualityInfo,int rotationAngle) {
  this(bitmap,resourceReleaser,qualityInfo,rotationAngle,ExifInterface.ORIENTATION_UNDEFINED);
}

/**
 * Creates a new instance of a CloseableStaticBitmap.
 *
 * @param bitmap the bitmap to wrap
 * @param resourceReleaser ResourceReleaser to release the bitmap to
 */
public CloseableStaticBitmap(
    Bitmap bitmap,int rotationAngle,int exifOrientation) {
  mBitmap = Preconditions.checkNotNull(bitmap);
  mBitmapReference = CloseableReference.of(
      mBitmap,Preconditions.checkNotNull(resourceReleaser));
  mQualityInfo = qualityInfo;
  mRotationAngle = rotationAngle;
  mExifOrientation = exifOrientation;
}

@Before
public void setUp() {
  mBitmap = Bitmap.createBitmap(WIDTH,HEIGHT,ExifInterface.ORIENTATION_norMAL);
}

public FlexByteArrayPool(
    MemoryTrimmableRegistry memoryTrimmableRegistry,PoolParams params) {
  Preconditions.checkArgument(params.maxnumThreads > 0);
  mDelegatePool = new SoftRefByteArrayPool(
      memoryTrimmableRegistry,params,NoOpPoolStatsTracker.getInstance());
  mResourceReleaser = new ResourceReleaser<byte[]>() {
    @Override
    public void release(byte[] unused) {
      FlexByteArrayPool.this.release(unused);
    }
  };
}

@Before
public void setUp() {
  MockitoAnnotations.initMocks(this);
  mResourceReleaser = mock(ResourceReleaser.class);
  mResultRef1 = CloseableReference.of(new Object(),mResourceReleaser);
  mResultRef2 = CloseableReference.of(new Object(),mResourceReleaser);
  mResultRef3 = CloseableReference.of(new Object(),mResourceReleaser);
  mException = mock(Exception.class);

  mDataSubscriber1 = mock(DataSubscriber.class);
  mDataSubscriber2 = mock(DataSubscriber.class);

  mSettableProducerContext = mock(SettableProducerContext.class);
  when(mSettableProducerContext.getId()).thenReturn(mRequestId);
  when(mSettableProducerContext.isPrefetch()).thenReturn(false);
  mProducer = mock(Producer.class);
  mDataSource = CloseableProducerToDataSourceAdapter.create(
      mProducer,mSettableProducerContext,mRequestListener);
  ArgumentCaptor<Consumer> captor = ArgumentCaptor.forClass(Consumer.class);
  verify(mRequestListener).onRequestStart(
      mSettableProducerContext.getimageRequest(),mSettableProducerContext.getCallerContext(),mRequestId,mSettableProducerContext.isPrefetch());
  verify(mProducer).produceResults(captor.capture(),any(SettableProducerContext.class));
  mInternalConsumer = captor.getValue();

  mDataSource.subscribe(mDataSubscriber1,CallerThreadExecutor.getInstance());
}

@Before
public void setUp() {

  mBitmap = MockBitmapFactory.create();
  mBitmapCounter = new BitmapCounter(MAX_BITMAP_COUNT,MAX_BITMAP_SIZE);

  mockStatic(BitmapCounterProvider.class);
  when(BitmapCounterProvider.get()).thenReturn(mBitmapCounter);

  mockStatic(BitmapFactory.class);
  when(BitmapFactory.decodeFileDescriptor(
          any(FileDescriptor.class),any(Rect.class),any(BitmapFactory.Options.class)))
      .thenReturn(mBitmap);

  mInputBuf = new byte[LENGTH];
  PooledByteBuffer input = new TrivialPooledByteBuffer(mInputBuf,POINTER);
  mByteBufferRef = CloseableReference.of(input);
  mEncodedImage = new EncodedImage(mByteBufferRef);

  mDecodeBuf = new byte[LENGTH + 2];
  mDecodeBufRef = CloseableReference.of(mDecodeBuf,mock(ResourceReleaser.class));

  mockStatic(Bitmaps.class);
  mGingerbreadPurgeableDecoder = new GingerbreadPurgeableDecoder();
}

@Before
public void setUp() {
  mFlexByteArrayPool = mock(FlexByteArrayPool.class);

  mBitmap = MockBitmapFactory.create();
  mBitmapCounter = new BitmapCounter(MAX_BITMAP_COUNT,MAX_BITMAP_SIZE);

  mockStatic(BitmapCounterProvider.class);
  when(BitmapCounterProvider.get()).thenReturn(mBitmapCounter);

  mockStatic(BitmapFactory.class);
  when(BitmapFactory.decodeByteArray(
          any(byte[].class),anyInt(),mock(ResourceReleaser.class));
  when(mFlexByteArrayPool.get(Integer.valueOf(LENGTH))).thenReturn(mDecodeBufRef);

  mockStatic(Bitmaps.class);
  mKitKatPurgeableDecoder = new KitKatPurgeableDecoder(mFlexByteArrayPool);
}

@Before
public void setUp() {
  mResourceReleaser = mock(ResourceReleaser.class);
  final byte[] bytes = new byte[256];
  for (int i = 0; i < 256; ++i) {
    bytes[i] = (byte) i;
  }
  InputStream unbufferedStream = new ByteArrayInputStream(bytes);
  mBuffer = new byte[10];
  mPooledByteArrayBufferedInputStream = new PooledByteArrayBufferedInputStream(
      unbufferedStream,mBuffer,mResourceReleaser);
}

public PooledByteArrayBufferedInputStream(
    InputStream inputStream,ResourceReleaser<byte[]> resourceReleaser) {
  mInputStream = Preconditions.checkNotNull(inputStream);
  mByteArray = Preconditions.checkNotNull(byteArray);
  mResourceReleaser = Preconditions.checkNotNull(resourceReleaser);
  mBufferedSize = 0;
  mBufferOffset = 0;
  mClosed = false;
}

/** Creates a new reference for the client. */
private synchronized CloseableReference<V> newClientReference(final Entry<K,new ResourceReleaser<V>() {
        @Override
        public void release(V unused) {
          releaseClientReference(entry);
        }
      });
}

/**
 * Creates a new instance of a CloseableStaticBitmap.
 *
 * @param bitmap the bitmap to wrap
 * @param resourceReleaser ResourceReleaser to release the bitmap to
 */
public CloseableStaticBitmap(
    Bitmap bitmap,ExifInterface.ORIENTATION_UNDEFINED);
}

/**
 * Creates a new instance of a CloseableStaticBitmap.
 *
 * @param bitmap the bitmap to wrap
 * @param resourceReleaser ResourceReleaser to release the bitmap to
 */
public CloseableStaticBitmap(
    Bitmap bitmap,Preconditions.checkNotNull(resourceReleaser));
  mQualityInfo = qualityInfo;
  mRotationAngle = rotationAngle;
  mExifOrientation = exifOrientation;
}

@Before
public void setUp() {
  mBitmap = Bitmap.createBitmap(WIDTH,ExifInterface.ORIENTATION_norMAL);
}

public FlexByteArrayPool(
    MemoryTrimmableRegistry memoryTrimmableRegistry,NoOpPoolStatsTracker.getInstance());
  mResourceReleaser = new ResourceReleaser<byte[]>() {
    @Override
    public void release(byte[] unused) {
      FlexByteArrayPool.this.release(unused);
    }
  };
}

@Before
public void setUp() {
  MockitoAnnotations.initMocks(this);
  mResourceReleaser = mock(ResourceReleaser.class);
  mResultRef1 = CloseableReference.of(new Object(),CallerThreadExecutor.getInstance());
}

@Before
public void setUp() {

  mBitmap = MockBitmapFactory.create();
  mBitmapCounter = new BitmapCounter(MAX_BITMAP_COUNT,mock(ResourceReleaser.class));

  mockStatic(Bitmaps.class);
  mGingerbreadPurgeableDecoder = new GingerbreadPurgeableDecoder();
}

@Before
public void setUp() {
  mFlexByteArrayPool = mock(FlexByteArrayPool.class);

  mBitmap = MockBitmapFactory.create();
  mBitmapCounter = new BitmapCounter(MAX_BITMAP_COUNT,mock(ResourceReleaser.class));
  when(mFlexByteArrayPool.get(Integer.valueOf(LENGTH))).thenReturn(mDecodeBufRef);

  mockStatic(Bitmaps.class);
  mKitKatPurgeableDecoder = new KitKatPurgeableDecoder(mFlexByteArrayPool);
}

@Before
public void setUp() {
  mResourceReleaser = mock(ResourceReleaser.class);
  final byte[] bytes = new byte[256];
  for (int i = 0; i < 256; ++i) {
    bytes[i] = (byte) i;
  }
  InputStream unbufferedStream = new ByteArrayInputStream(bytes);
  mBuffer = new byte[10];
  mPooledByteArrayBufferedInputStream = new PooledByteArrayBufferedInputStream(
      unbufferedStream,mResourceReleaser);
}

public ResourceReleaser<Bitmap> getReleaser() {
  return mUnpooledBitmapsReleaser;
}

public ResourceReleaser<Bitmap> getReleaser() {
  return mUnpooledBitmapsReleaser;
}

@Override
public RecordSet getRecordSet(
        ConnectorTransactionHandle transaction,ConnectorSession session,ConnectorSplit split,List<? extends ColumnHandle> columns
) {
    EthereumSplit ethereumSplit = convertSplit(split);

    ImmutableList.Builder<EthereumColumnHandle> handleBuilder = ImmutableList.builder();

    for (ColumnHandle handle : columns) {
        EthereumColumnHandle columnHandle = convertColumnHandle(handle);
        handleBuilder.add(columnHandle);
    }

    return new EthereumRecordSet(web3j,handleBuilder.build(),ethereumSplit);
}

@JsonCreator
public HDFSTableLayoutHandle(
        @JsonProperty("table") HDFSTableHandle table,@JsonProperty("fiberColumn") HDFSColumnHandle fiberColumn,@JsonProperty("timestampColumn") HDFSColumnHandle timestampColumn,@JsonProperty("fiberFunction") Function fiberFunction,@JsonProperty("storageFormat") StorageFormat storageFormat,@JsonProperty("predicates") Optional<TupleDomain<ColumnHandle>> predicates)
{
    this.table = requireNonNull(table,"table is null");
    this.fiberColumn = requireNonNull(fiberColumn,"fiberColumn is null");
    this.timestampColumn = requireNonNull(timestampColumn,"timestampColumn is null");
    this.fiberFunction = requireNonNull(fiberFunction,"fiberFunc is null");
    this.storageFormat = requireNonNull(storageFormat,"storageFormat is null");
    this.predicates = requireNonNull(predicates,"predicates is null");
}

@Override
public ConnectorPageSource createPageSource(ConnectorTransactionHandle transactionHandle,List<ColumnHandle> columns)
{
    List<HDFSColumnHandle> hdfsColumns = columns.stream()
            .map(col -> (HDFSColumnHandle) col)
            .collect(Collectors.toList());
    HDFssplit hdfssplit = checkType(split,HDFssplit.class,"hdfs split");
    Path path = new Path(hdfssplit.getPath());

    Optional<ConnectorPageSource> pageSource = createHDFSPageSource(
            path,hdfssplit.getStart(),hdfssplit.getLen(),hdfsColumns);
    if (pageSource.isPresent()) {
        return pageSource.get();
    }
    throw new RuntimeException("Could not find a file reader for split " + hdfssplit);
}

@Override
/**
 * @
 */
public RecordSet getRecordSet(ConnectorTransactionHandle transactionHandle,List<? extends ColumnHandle> columns)
{
    requireNonNull(split,"split is null");
    KuduSplit kuduSplit = checkType(split,KuduSplit.class,"split");

    ImmutableList.Builder<KuduColumnHandle> handles = ImmutableList.builder();
    for (ColumnHandle handle : columns) {
        handles.add(checkType(handle,KuduColumnHandle.class,"handle"));
    }

    return new KuduRecordSet(kuduTable,kuduClientManager,kuduSplit,handles.build());
}

@Override
public Map<String,ColumnHandle> getColumnHandles(ConnectorSession session,ConnectorTableHandle tableHandle)
{
    ExampleTableHandle exampleTableHandle = checkType(tableHandle,ExampleTableHandle.class,"tableHandle");
    checkArgument(exampleTableHandle.getConnectorId().equals(connectorId),"tableHandle is not for this connector");

    ExampleTable table = exampleClient.getTable(exampleTableHandle.getSchemaName(),exampleTableHandle.getTableName());
    if (table == null) {
        throw new TableNotFoundException(exampleTableHandle.toSchemaTableName());
    }

    ImmutableMap.Builder<String,ColumnHandle> columnHandles = ImmutableMap.builder();
    int index = 0;
    for (ColumnMetadata column : table.getColumnsMetadata()) {
        columnHandles.put(column.getName(),new ExampleColumnHandle(connectorId,column.getName(),column.getType(),index));
        index++;
    }
    return columnHandles.build();
}

@Override
public PlanNode visitIndexSource(IndexSourceNode node,RewriteContext<Set<Symbol>> context)
{
    List<Symbol> newOutputSymbols = node.getoutputSymbols().stream()
            .filter(context.get()::contains)
            .collect(toImmutableList());

    Set<Symbol> newLookupSymbols = node.getLookupSymbols().stream()
            .filter(context.get()::contains)
            .collect(toImmutableSet());

    Set<Symbol> requiredAssignmentSymbols = context.get();
    if (!node.getEffectiveTupleDomain().isNone()) {
        Set<Symbol> requiredSymbols = Maps.filterValues(node.getAssignments(),in(node.getEffectiveTupleDomain().getDomains().get().keySet())).keySet();
        requiredAssignmentSymbols = Sets.union(context.get(),requiredSymbols);
    }
    Map<Symbol,ColumnHandle> newAssignments = Maps.filterKeys(node.getAssignments(),in(requiredAssignmentSymbols));

    return new IndexSourceNode(node.getId(),node.getIndexHandle(),node.getTableHandle(),newLookupSymbols,newOutputSymbols,newAssignments,node.getEffectiveTupleDomain());
}

@Test
public void testTypesRcBinaryRecordCursor()
        throws Exception
{
    ConnectorSession session = newSession();

    if (Metadata.getTableHandle(session,new SchemaTableName(database,"presto_test_types_rcbinary")) == null) {
        return;
    }

    ConnectorTableHandle tableHandle = getTableHandle(new SchemaTableName(database,"presto_test_types_rcbinary"));
    ConnectorTableMetadata tableMetadata = Metadata.getTableMetadata(session,tableHandle);
    HiveSplit hiveSplit = getHiveSplit(tableHandle);
    List<ColumnHandle> columnHandles = ImmutableList.copyOf(Metadata.getColumnHandles(session,tableHandle).values());

    ConnectorPageSourceProvider pageSourceProvider = new HivePageSourceProvider(
            new HiveClientConfig().setTimeZone(timeZone.getID()),hdfsEnvironment,ImmutableSet.<HiveRecordCursorProvider>of(new ColumnarBinaryHiveRecordCursorProvider()),ImmutableSet.<HivePageSourceFactory>of(),TYPE_MANAGER);

    ConnectorPageSource pageSource = pageSourceProvider.createPageSource(session,hiveSplit,columnHandles);
    assertGetRecords(RCBINARY,tableMetadata,pageSource,columnHandles);
}

@Test
public void testRenameColumn()
        throws Exception
{
    assertNull(Metadata.getTableHandle(SESSION,DEFAULT_TEST_ORDERS));
    Metadata.createTable(SESSION,getordersTable());
    ConnectorTableHandle tableHandle = Metadata.getTableHandle(SESSION,DEFAULT_TEST_ORDERS);
    assertInstanceOf(tableHandle,RaptorTableHandle.class);

    RaptorTableHandle raptorTableHandle = (RaptorTableHandle) tableHandle;
    ColumnHandle columnHandle = Metadata.getColumnHandles(SESSION,tableHandle).get("orderkey");

    Metadata.renameColumn(SESSION,raptorTableHandle,columnHandle,"orderkey_renamed");

    assertNull(Metadata.getColumnHandles(SESSION,tableHandle).get("orderkey"));
    assertNotNull(Metadata.getColumnHandles(SESSION,tableHandle).get("orderkey_renamed"));
}

@Test
public void testGetPartitionSplitsTableOfflinePartition()
        throws Exception
{
    ConnectorSession session = newSession();

    ConnectorTableHandle tableHandle = getTableHandle(tableOfflinePartition);
    assertNotNull(tableHandle);

    ColumnHandle dsColumn = Metadata.getColumnHandles(session,tableHandle).get("ds");
    assertNotNull(dsColumn);

    Domain domain = Domain.singleValue(VARCHAR,utf8Slice("2012-12-30"));
    TupleDomain<ColumnHandle> tupleDomain = TupleDomain.withColumnDomains(ImmutableMap.of(dsColumn,domain));
    List<ConnectorTableLayoutResult> tableLayoutResults = Metadata.getTableLayouts(session,tableHandle,new Constraint<>(tupleDomain,bindings -> true),Optional.empty());
    try {
        getSplitCount(splitManager.getSplits(session,getonlyElement(tableLayoutResults).getTableLayout().getHandle()));
        fail("Expected PartitionOfflineException");
    }
    catch (PartitionOfflineException e) {
        assertEquals(e.getTableName(),tableOfflinePartition);
        assertEquals(e.getPartition(),"ds=2012-12-30");
    }
}

public <E extends TpchEntity> RecordSet getRecordSet(
        TpchTable<E> table,List<? extends ColumnHandle> columns,double scaleFactor,int partNumber,int totalParts)
{
    ImmutableList.Builder<TpchColumn<E>> builder = ImmutableList.builder();
    for (ColumnHandle column : columns) {
        String columnName = checkType(column,TpchColumnHandle.class,"column").getColumnName();
        if (columnName.equalsIgnoreCase(TpchMetadata.ROW_NUMBER_COLUMN_NAME)) {
            builder.add(new RowNumberTpchColumn<E>());
        }
        else {
            builder.add(table.getColumn(columnName));
        }
    }

    return createTpchRecordSet(table,builder.build(),scaleFactor,partNumber + 1,totalParts);
}

@Override
public Map<String,ConnectorTableHandle tableHandle)
{
    SchemaTableName tableName = schemaTableName(tableHandle);
    Optional<Table> table = metastore.getTable(tableName.getSchemaName(),tableName.getTableName());
    if (!table.isPresent()) {
        throw new TableNotFoundException(tableName);
    }
    ImmutableMap.Builder<String,ColumnHandle> columnHandles = ImmutableMap.builder();
    for (HiveColumnHandle columnHandle : hiveColumnHandles(connectorId,table.get())) {
        if (!columnHandle.getName().equals(SAMPLE_WEIGHT_COLUMN_NAME)) {
            columnHandles.put(columnHandle.getName(),columnHandle);
        }
    }
    return columnHandles.build();
}

@Override
public ConnectorSplitSource getSplits(ConnectorTransactionHandle transaction,ConnectorTableLayoutHandle layout)
{
    JmxTableLayoutHandle jmxLayout = checkType(layout,JmxTableLayoutHandle.class,"layout");
    JmxTableHandle tableHandle = jmxLayout.getTable();
    TupleDomain<ColumnHandle> predicate = jmxLayout.getConstraint();

    //Todo is there a better way to get the node column?
    JmxColumnHandle nodeColumnHandle = tableHandle.getColumns().get(0);

    List<ConnectorSplit> splits = nodeManager.getNodes(ACTIVE)
            .stream()
            .filter(node -> {
                NullableValue value = NullableValue.of(VARCHAR,utf8Slice(node.getNodeIdentifier()));
                return predicate.overlaps(fromFixedValues(ImmutableMap.of(nodeColumnHandle,value)));
            })
            .map(node -> new JmxSplit(tableHandle,ImmutableList.of(node.getHostAndPort())))
            .collect(toList());

    return new FixedSplitSource(connectorId,splits);
}

@Override
public RecordSet getRecordSet(ConnectorTransactionHandle transaction,List<? extends ColumnHandle> columns)
{
    CassandraSplit cassandraSplit = checkType(split,CassandraSplit.class,"split");

    List<CassandraColumnHandle> cassandraColumns = columns.stream()
            .map(column -> checkType(column,CassandraColumnHandle.class,"columnHandle"))
            .collect(toList());

    String selectCql = CassandraCqlUtils.selectFrom(cassandraSplit.getCassandratableHandle(),cassandraColumns).getQueryString();
    StringBuilder sb = new StringBuilder(selectCql);
    if (sb.charat(sb.length() - 1) == ';') {
        sb.setLength(sb.length() - 1);
    }
    sb.append(cassandraSplit.getWhereClause());
    String cql = sb.toString();
    log.debug("Creating record set: %s",cql);

    return new CassandraRecordSet(cassandraSession,cassandraSplit.getSchema(),cql,cassandraColumns);
}

@Test
public void testTypesRcTextRecordCursor()
        throws Exception
{
    ConnectorSession session = newSession();

    if (Metadata.getTableHandle(session,"presto_test_types_rctext")) == null) {
        return;
    }

    ConnectorTableHandle tableHandle = getTableHandle(new SchemaTableName(database,"presto_test_types_rctext"));
    ConnectorTableMetadata tableMetadata = Metadata.getTableMetadata(session,ImmutableSet.<HiveRecordCursorProvider>of(new ColumnarTextHiveRecordCursorProvider()),columnHandles);
    assertGetRecords(RCTEXT,columnHandles);
}

@Override
public Void visitIndexSource(IndexSourceNode node,Void context)
{
    TableHandle tableHandle = node.getTableHandle();
    Optional<ColumnHandle> sampleWeightColumn = Metadata.getSampleWeightColumnHandle(session,tableHandle);

    Set<Column> columns = new HashSet<>();
    for (ColumnHandle columnHandle : node.getAssignments().values()) {
        if (!columnHandle.equals(sampleWeightColumn.orElse(null))) {
            columns.add(createColumnEntry(Metadata.getColumnMetadata(session,columnHandle)));
        }
    }

    inputs.put(createTableEntry(Metadata.getTableMetadata(session,tableHandle)),columns);

    return null;
}

@Override
public PlanNode visitTableScan(TableScanNode node,RewriteContext<Set<Symbol>> context)
{
    Set<Symbol> requiredTableScanOutputs = context.get().stream()
            .filter(node.getoutputSymbols()::contains)
            .collect(toImmutableSet());

    List<Symbol> newOutputSymbols = node.getoutputSymbols().stream()
            .filter(requiredTableScanOutputs::contains)
            .collect(toImmutableList());

    Map<Symbol,in(requiredTableScanOutputs));

    return new TableScanNode(
            node.getId(),node.getTable(),node.getLayout(),node.getCurrentConstraint(),node.getoriginalConstraint());
}

@Override
public ConnectorPageSource createPageSource(ConnectorTransactionHandle transactionHandle,List<ColumnHandle> columns)
{
    InternalTable table = getInternalTable(transactionHandle,session,split,columns);

    List<Integer> channels = new ArrayList<>();
    for (ColumnHandle column : columns) {
        String columnName = checkType(column,informationSchemaColumnHandle.class,"column").getColumnName();
        int columnIndex = table.getColumnIndex(columnName);
        channels.add(columnIndex);
    }

    ImmutableList.Builder<Page> pages = ImmutableList.builder();
    for (Page page : table.getPages()) {
        Block[] blocks = new Block[channels.size()];
        for (int index = 0; index < blocks.length; index++) {
            blocks[index] = page.getBlock(channels.get(index));
        }
        pages.add(new Page(page.getPositionCount(),blocks));
    }
    return new FixedPageSource(pages.build());
}

private InternalTable getInternalTable(ConnectorTransactionHandle transactionHandle,ConnectorSession connectorSession,ConnectorSplit connectorSplit,List<ColumnHandle> columns)
{
    informationSchemaTransactionHandle transaction = checkType(transactionHandle,informationSchemaTransactionHandle.class,"transaction");
    informationSchemaSplit split = checkType(connectorSplit,informationSchemaSplit.class,"split");

    requireNonNull(columns,"columns is null");

    informationSchemaTableHandle handle = split.getTableHandle();
    Map<String,NullableValue> filters = split.getFilters();

    Session session = Session.builder(Metadata.getSessionPropertyManager())
            .setTransactionId(transaction.getTransactionId())
            .setQueryId(new QueryId(connectorSession.getQueryId()))
            .setIdentity(connectorSession.getIdentity())
            .setSource("information_schema")
            .setCatalog("") // default catalog is not be used
            .setSchema("") // default schema is not be used
            .setTimeZoneKey(connectorSession.getTimeZoneKey())
            .setLocale(connectorSession.getLocale())
            .setStartTime(connectorSession.getStartTime())
            .build();

    return getinformationSchemaTable(session,handle.getCatalogName(),handle.getSchemaTableName(),filters);
}

/**
 * Return a list of table layouts that satisfy the given constraint.
 * <p>
 * For each layout,connectors must return an "unenforced constraint" representing the part of the constraint summary that isn't guaranteed by the layout.
 *
 * @param session session
 * @param table table
 * @param constraint constraint
 * @param desiredColumns desired columns
 */
@Override
public List<ConnectorTableLayoutResult> getTableLayouts(ConnectorSession session,ConnectorTableHandle table,Constraint<ColumnHandle> constraint,Optional<Set<ColumnHandle>> desiredColumns)
{
    // get table name from ConnectorTableHandle
    HDFSTableHandle hdfsTable = checkType(table,HDFSTableHandle.class,"table");
    SchemaTableName tableName = hdfsTable.getSchemaTableName();
    // create HDFSTableLayoutHandle
    HDFSTableLayoutHandle tableLayout = MetaDataQuery.getTableLayout(connectorId,tableName.getSchemaName(),tableName.getTableName()).orElse(null);
    tableLayout.setPredicates(constraint.getSummary() != null ? Optional.of(constraint.getSummary()) : Optional.empty());
    // ConnectorTableLayout layout = new ConnectorTableLayout(HDFSTableLayoutHandle)
    ConnectorTableLayout layout = getTableLayout(session,tableLayout);

    return ImmutableList.of(new ConnectorTableLayoutResult(layout,constraint.getSummary()));
}

/**
 * Gets all of the columns on the specified table,or an empty map if the columns can not be enumerated.
 *
 * @param session session
 * @param tableHandle table handle
 * @throws RuntimeException if table handle is no longer valid
 */
@Override
public Map<String,ConnectorTableHandle tableHandle)
{
    HDFSTableHandle table = checkType(tableHandle,"table");
    List<HDFSColumnHandle> cols = MetaDataQuery.getTableColumnHandle(connectorId,table.getSchemaName(),table.getTableName())
            .orElse(new ArrayList<>());
    Map<String,ColumnHandle> columnMap = new HashMap<>();
    for (HDFSColumnHandle col : cols) {
        columnMap.putIfAbsent(col.getName(),col);
    }
    return columnMap;
}

@Override
public RecordSet getRecordSet(
        ConnectorTransactionHandle connectorTransactionHandle,List<? extends ColumnHandle> list)
{
    RestConnectorSplit split = Types.checkType(connectorSplit,RestConnectorSplit.class,"split");
    // Todo fix below cast
    List<RestColumnHandle> restColumnHandles = (List<RestColumnHandle>) list;

    SchemaTableName schemaTableName = split.getTableHandle().getSchemaTableName();
    Collection<? extends List<?>> rows = rest.getRows(schemaTableName);
    ConnectorTableMetadata tableMetadata = rest.getTableMetadata(schemaTableName);

    List<Integer> columnIndexes = restColumnHandles.stream()
            .map(column -> {
                int index = 0;
                for (ColumnMetadata columnMetadata : tableMetadata.getColumns()) {
                    if (columnMetadata.getName().equalsIgnoreCase(column.getName())) {
                        return index;
                    }
                    index++;
                }
                throw new IllegalStateException("UnkNown column: " + column.getName());
            })
            .collect(toList());

    Collection<? extends List<?>> mappedRows = rows.stream()
            .map(row -> columnIndexes.stream()
                    .map(index -> row.get(index))
                    .collect(toList()))
            .collect(toList());

    List<Type> mappedTypes = restColumnHandles.stream()
            .map(RestColumnHandle::getType)
            .collect(toList());
    return new InMemoryRecordSet(mappedTypes,mappedRows);
}

@Override
public ConnectorHandleResolver getHandleResolver()
{
    return new ConnectorHandleResolver()
    {
        public Class<? extends ConnectorTableHandle> getTableHandleClass()
        {
            return RestTableHandle.class;
        }

        public Class<? extends ColumnHandle> getColumnHandleClass()
        {
            return RestColumnHandle.class;
        }

        public Class<? extends ConnectorSplit> getSplitClass()
        {
            return RestConnectorSplit.class;
        }

        public Class<? extends ConnectorTableLayoutHandle> getTableLayoutHandleClass()
        {
            return RestConnectorTableLayoutHandle.class;
        }

        @Override
        public Class<? extends ConnectorTransactionHandle> getTransactionHandleClass()
        {
            return RestTransactionHandle.class;
        }

        @Override
        public Class<? extends ConnectorInsertTableHandle> getInsertTableHandleClass()
        {
            return RestInsertTableHandle.class;
        }
    };
}

@Override
public List<ConnectorTableLayoutResult> getTableLayouts(ConnectorSession connectorSession,ConnectorTableHandle connectorTableHandle,Optional<Set<ColumnHandle>> optional)
{
    RestTableHandle tableHandle = Types.checkType(connectorTableHandle,RestTableHandle.class,"tableHandle");
    return ImmutableList.of(
            new ConnectorTableLayoutResult(
                    getTableLayout(connectorSession,new RestConnectorTableLayoutHandle(tableHandle)),TupleDomain.all()));
}

@Override
public ColumnMetadata getColumnMetadata(
        ConnectorSession session,ConnectorTableHandle tableHandle,ColumnHandle columnHandle
) {
    convertTableHandle(tableHandle);
    return convertColumnHandle(columnHandle).getColumnMetadata();
}

@Override
public RecordSet getRecordSet(ConnectorTransactionHandle connectorTransactionHandle,List<? extends ColumnHandle> list)
{
    log.info("informatION: AmpoolRecordSetProvider getRecordSet() called.");

    requireNonNull(connectorSplit,"split is null");
    AmpoolSplit ampoolSplit = (AmpoolSplit) connectorSplit;
    checkArgument(ampoolSplit.getConnectorId().equals(connectorId),"split is not for this connector");

    ImmutableList.Builder<AmpoolColumnHandle> handles = ImmutableList.builder();
    for (ColumnHandle handle : list)
    {
        handles.add((AmpoolColumnHandle) handle);
    }


    // Todo: Projections and filters on Ampool side
    Iterator<Row> iterator;
    if (ampoolClient.existsFTable(ampoolSplit.getTableName()))
        iterator = ampoolClient.getFTable(ampoolSplit.getTableName()).getScanner(new Scan()).iterator();
    else if (ampoolClient.existsMTable(ampoolSplit.getTableName()))
        iterator = ampoolClient.getMTable(ampoolSplit.getTableName()).getScanner(new Scan()).iterator();
    else
        iterator = null;

    return new AmpoolRecordSet(ampoolSplit,handles.build(),iterator);
}

@Override
public List<ConnectorTableLayoutResult> getTableLayouts(ConnectorSession session,Optional<Set<ColumnHandle>> desiredColumns)
{
    KuduTableHandle tableHandle = checkType(table,KuduTableHandle.class,"tableHandle");
    ConnectorTableLayout layout = new ConnectorTableLayout(new KuduTableLayoutHandle(tableHandle,constraint.getSummary()));
    return ImmutableList.of(new ConnectorTableLayoutResult(layout,constraint.getSummary()));
}

private Map<String,ColumnHandle> getColumnHandles(KuduTableHandle tableHandle)
{
    ImmutableMap.Builder<String,ColumnHandle> columnHandles = ImmutableMap.builder();
    int index = 0;
    KuduClient kuduClient = kuduClientManager.getClient();

    for (ColumnMetadata column : kuduTables.getColumns(kuduClient,tableHandle)) {
        int ordinalPosition;
        ordinalPosition = index;
        index++;
        columnHandles.put(column.getName(),new KuduColumnHandle(column.getName(),ordinalPosition));
    }
    kuduClientManager.close(kuduClient);
    return columnHandles.build();
}

@JsonCreator
public KuduTableLayoutHandle(
        @JsonProperty("table") KuduTableHandle table,@JsonProperty("constraint") TupleDomain<ColumnHandle> constraint)
{
    this.table = requireNonNull(table,"table is null");
    this.constraint = requireNonNull(constraint,"constraint is null");
}

@Override
public ConnectorPageSource createPageSource(Session session,Split split,List<ColumnHandle> columns)
{
    requireNonNull(split,"split is null");
    requireNonNull(columns,"columns is null");

    // assumes connectorId and catalog are the same
    ConnectorSession connectorSession = session.toConnectorSession(split.getConnectorId());
    return getPageSourceProvider(split).createPageSource(split.getTransactionHandle(),connectorSession,split.getConnectorSplit(),columns);
}

@Override
public Map<String,ConnectorTableHandle tableHandle)
{
    ImmutableMap.Builder<String,ColumnHandle> builder = ImmutableMap.builder();
    int index = 0;
    for (ColumnMetadata columnMetadata : getTableMetadata(session,tableHandle).getColumns()) {
        builder.put(columnMetadata.getName(),new InMemoryColumnHandle(columnMetadata.getName(),index,columnMetadata.getType()));
        index++;
    }
    return builder.build();
}

@Override
public RecordSet getRecordSet(ConnectorSession session,"partitionChunk is null");
    ExampleSplit exampleSplit = checkType(split,ExampleSplit.class,"split");
    checkArgument(exampleSplit.getConnectorId().equals(connectorId),"split is not for this connector");

    ImmutableList.Builder<ExampleColumnHandle> handles = ImmutableList.builder();
    for (ColumnHandle handle : columns) {
        handles.add(checkType(handle,ExampleColumnHandle.class,"handle"));
    }

    return new ExampleRecordSet(exampleSplit,handles.build());
}

@Override
public RecordSet getRecordSet(ConnectorTransactionHandle transactionHandle,List<? extends ColumnHandle> columns)
{
    Kinesissplit kinesissplit = handleResolver.convertSplit(split);

    ImmutableList.Builder<KinesisColumnHandle> handleBuilder = ImmutableList.builder();
    ImmutableMap.Builder<KinesisColumnHandle,KinesisFieldDecoder<?>> messageFieldDecoderBuilder = ImmutableMap.builder();

    KinesisRowDecoder messageDecoder = registry.getRowDecoder(kinesissplit.getMessageDataFormat());

    for (ColumnHandle handle : columns) {
        KinesisColumnHandle columnHandle = handleResolver.convertColumnHandle(handle);
        handleBuilder.add(columnHandle);

        if (!columnHandle.isInternal()) {
            KinesisFieldDecoder<?> fieldDecoder = registry.getFieldDecoder(kinesissplit.getMessageDataFormat(),columnHandle.getType().getJavaType(),columnHandle.getDataFormat());

            messageFieldDecoderBuilder.put(columnHandle,fieldDecoder);
        }
    }

    ImmutableList<KinesisColumnHandle> handles = handleBuilder.build();
    ImmutableMap<KinesisColumnHandle,KinesisFieldDecoder<?>> messageFieldDecoders = messageFieldDecoderBuilder.build();

    return new KinesisRecordSet(kinesissplit,clientManager,handles,messageDecoder,messageFieldDecoders,kinesisConnectorConfig);
}

@Override
public Map<String,ConnectorTableHandle tableHandle)
{
    RaptorTableHandle raptorTableHandle = checkType(tableHandle,RaptorTableHandle.class,"tableHandle");
    ImmutableMap.Builder<String,ColumnHandle> builder = ImmutableMap.builder();
    for (TableColumn tableColumn : dao.listTableColumns(raptorTableHandle.getTableId())) {
        if (tableColumn.getColumnName().equals(SAMPLE_WEIGHT_COLUMN_NAME)) {
            continue;
        }
        builder.put(tableColumn.getColumnName(),getRaptorColumnHandle(tableColumn));
    }
    RaptorColumnHandle uuidColumn = shardUuidColumnHandle(connectorId);
    builder.put(uuidColumn.getColumnName(),uuidColumn);
    return builder.build();
}

private List<String> getFilteredPartitionNames(Hivemetastore metastore,SchemaTableName tableName,List<HiveColumnHandle> partitionKeys,TupleDomain<ColumnHandle> effectivePredicate)
{
    checkArgument(effectivePredicate.getDomains().isPresent());

    List<String> filter = new ArrayList<>();
    for (HiveColumnHandle partitionKey : partitionKeys) {
        Domain domain = effectivePredicate.getDomains().get().get(partitionKey);
        if (domain != null && domain.isNullableSingleValue()) {
            Object value = domain.getNullableSingleValue();
            if (value == null) {
                filter.add(HivePartitionKey.HIVE_DEFAULT_DYNAMIC_PARTITION);
            }
            else if (value instanceof Slice) {
                filter.add(((Slice) value).toStringUtf8());
            }
            else if ((value instanceof Boolean) || (value instanceof Double) || (value instanceof Long)) {
                if (assumeCanonicalPartitionKeys) {
                    filter.add(value.toString());
                }
                else {
                    // Hive treats '0','false',and 'False' the same. However,the metastore differentiates between these.
                    filter.add(PARTITION_VALUE_WILDCARD);
                }
            }
            else {
                throw new PrestoException(NOT_SUPPORTED,"Only Boolean,Double and Long partition keys are supported");
            }
        }
        else {
            filter.add(PARTITION_VALUE_WILDCARD);
        }
    }

    // fetch the partition names
    return metastore.getPartitionNamesByParts(tableName.getSchemaName(),tableName.getTableName(),filter)
            .orElseThrow(() -> new TableNotFoundException(tableName));
}

@Test
public void testNone()
        throws Exception
{
    Assert.assertTrue(TupleDomain.none().isNone());
    Assert.assertEquals(TupleDomain.<ColumnHandle>none(),TupleDomain.withColumnDomains(ImmutableMap.of(
                    A,Domain.none(BIGINT))));
    Assert.assertEquals(TupleDomain.<ColumnHandle>none(),Domain.all(BIGINT),B,Domain.none(VARCHAR))));
}

@Override
public ConnectorIndex getIndex(ConnectorSession session,ConnectorIndexHandle indexHandle,List<ColumnHandle> lookupSchema,List<ColumnHandle> outputSchema)
{
    try (threadcontextClassLoader ignored = new threadcontextClassLoader(classLoader)) {
        return delegate.getIndex(session,indexHandle,lookupSchema,outputSchema);
    }
}

@Override
public Map<String,ColumnHandle> getColumnHandles(Session session,TableHandle tableHandle)
{
    ConnectorEntry entry = lookupConnectorFor(tableHandle);
    ConnectorMetadata Metadata = entry.getMetadata(session);
    return Metadata.getColumnHandles(session.toConnectorSession(entry.getCatalog()),tableHandle.getConnectorHandle());
}

@Test
public void testIntersection()
        throws Exception
{
    TupleDomain<ColumnHandle> tupleDomain1 = TupleDomain.withColumnDomains(
            ImmutableMap.<ColumnHandle,Domain>builder()
                    .put(A,Domain.all(VARCHAR))
                    .put(B,Domain.notNull(DOUBLE))
                    .put(C,Domain.singleValue(BIGINT,1L))
                    .put(D,Domain.create(ValueSet.ofRanges(Range.greaterThanorEqual(DOUBLE,0.0)),true))
                    .build());

    TupleDomain<ColumnHandle> tupleDomain2 = TupleDomain.withColumnDomains(
            ImmutableMap.<ColumnHandle,Domain.singleValue(VARCHAR,utf8Slice("value")))
                    .put(B,Domain.singleValue(DOUBLE,0.0))
                    .put(C,Domain.create(ValueSet.ofRanges(Range.lessthan(DOUBLE,10.0)),false))
                    .build());

    TupleDomain<ColumnHandle> expectedTupleDomain = TupleDomain.withColumnDomains(
            ImmutableMap.<ColumnHandle,Domain.create(ValueSet.ofRanges(Range.range(DOUBLE,0.0,true,10.0,false)),false))
                    .build());

    Assert.assertEquals(tupleDomain1.intersect(tupleDomain2),expectedTupleDomain);
}

@Override
public ConnectorTableLayout getTableLayout(ConnectorSession session,ConnectorTableLayoutHandle handle)
{
    RedisTableLayoutHandle layout = convertLayout(handle);

    // tables in this connector have a single layout
    return getTableLayouts(session,layout.getTable(),Constraint.<ColumnHandle>alwaysTrue(),Optional.empty())
            .get(0)
            .getTableLayout();
}

@Override
public List<ConnectorTableLayoutResult> getTableLayouts(
        ConnectorSession session,Optional<Set<ColumnHandle>> desiredColumns)
{
    try (threadcontextClassLoader ignored = new threadcontextClassLoader(classLoader)) {
        return delegate.getTableLayouts(session,table,constraint,desiredColumns);
    }
}

@Override
public Connector create(String connectorId,Map<String,String> config,ConnectorContext context)
{
    requireNonNull(config,"config is null");

    try {
        Bootstrap app = new Bootstrap(
                new JsonModule(),new HDFSModule(connectorId,context.getTypeManager())
        );

        Injector injector = app
                .strictConfig()
                .donotinitializeLogging()
                .setrequiredConfigurationProperties(config)
                .initialize();

        return injector.getInstance(HDFSConnector.class);
    }
    catch (Exception e) {
        e.printstacktrace();
    }
    return null;
}

@Override
public Connector create(final String connectorId,String> requiredConfig,ConnectorContext context)
{
    requireNonNull(requiredConfig,"config is null");

    try {
        Bootstrap app = new Bootstrap(
                binder -> binder.bind(NodeManager.class).toInstance(context.getNodeManager()),new KuduModule(connectorId));

        Injector injector = app
                .strictConfig()
                .donotinitializeLogging()
                .setrequiredConfigurationProperties(requiredConfig)
                .initialize();

        return injector.getInstance(KuduConnector.class);
    }
    catch (Exception e) {
        throw Throwables.propagate(e);
    }
}

@Override
public Connector create(String connectorId,ConnectorContext context) {
  Path basePath = new Path(config.get(BASEPATH));
  String spreadsheetSubDir = config.get(SUBDIR);
  String useFileCacheStr = config.get(USE_FILE_CACHE);
  String proxyUserStr = config.get(PROXY_USER);
  boolean proxyUser = false;
  if (proxyUserStr != null) {
    proxyUser = Boolean.parseBoolean(proxyUserStr);
  }
  boolean useFileCache = true;
  if (useFileCacheStr != null) {
    useFileCache = Boolean.parseBoolean(useFileCacheStr);
  }
  try {
    return new SpreadsheetConnector(UserGroupinformation.getCurrentUser(),_configuration,basePath,spreadsheetSubDir,useFileCache,proxyUser);
  } catch (IOException e) {
    throw new RuntimeException(e);
  }
}

@Override
public Connector create(String s,ConnectorContext context)
{
    NodeManager nodeManager = context.getNodeManager();

    return new RestConnector(nodeManager,restFactory.create(config));
}

@Override
    public Connector create(String connectorId,ConnectorContext context) {
        requireNonNull(connectorId,"connectorId is null");
        requireNonNull(config,"config is null");

        try {
            Bootstrap app = new Bootstrap(
//                    new JsonModule(),new EthereumConnectorModule(),binder -> {
                        binder.bind(EthereumConnectorId.class).toInstance(new EthereumConnectorId(connectorId));
                        binder.bind(TypeManager.class).toInstance(context.getTypeManager());
                        binder.bind(NodeManager.class).toInstance(context.getNodeManager());
                    }
            );

            Injector injector = app.strictConfig()
                    .donotinitializeLogging()
                    .setrequiredConfigurationProperties(config)
                    .initialize();

            return injector.getInstance(EthereumConnector.class);
        }
        catch (Exception e) {
            throw Throwables.propagate(e);
        }
    }

public Connector create(final String connectorId,ConnectorContext context) {
  requireNonNull(requiredConfig,"requiredConfig is null");

  final String
      locator_host =
      requiredConfig
          .getorDefault(MonarchProperties.LOCATOR_HOST,MonarchProperties.LOCATOR_HOST_DEFAULT);
  final int
      locator_port =
      Integer.parseInt(requiredConfig
          .getorDefault(MonarchProperties.LOCATOR_PORT,MonarchProperties.LOCATOR_PORT_DEFAULT));

  // Create a client that connects to the Ampool cluster via a locator (that is already running!).
  final Properties props = new Properties();
  props.setProperty(Constants.MClientCacheconfig.MONARCH_CLIENT_LOG,requiredConfig
      .getorDefault(MonarchProperties.MONARCH_CLIENT_LOG,MonarchProperties.MONARCH_CLIENT_LOG_DEFAULT_LOCATION));
  final AmpoolClient aClient = new AmpoolClient(locator_host,locator_port,props);
  log.info("informatION: AmpoolClient created successfully.");

  try {
    Bootstrap
        app =
        new Bootstrap(new AmpoolModule(connectorId,aClient,context.getTypeManager()));

    Injector injector = app
        .donotinitializeLogging()
        .setrequiredConfigurationProperties(requiredConfig)
        .initialize();

    log.info("informatION: Injector initialized successfully.");
    return injector.getInstance(AmpoolConnector.class);
  } catch (Exception e) {
    throw Throwables.propagate(e);
  }
}

@Override
public Connector create(String connectorId,ConnectorContext context)
{
    log.info("In connector factory create method.  Connector id: " + connectorId);
    requireNonNull(connectorId,"connectorId is null");
    requireNonNull(config,new KinesisConnectorModule(),binder -> {
                    binder.bindConstant().annotatedWith(Names.named("connectorId")).to(connectorId);
                    binder.bind(ConnectorId.class).toInstance(new ConnectorId(connectorId));
                    binder.bind(TypeManager.class).toInstance(context.getTypeManager());
                    binder.bind(NodeManager.class).toInstance(context.getNodeManager());
                    // Note: moved creation from KinesisConnectorModule because connector manager accesses it earlier!
                    binder.bind(KinesisHandleResolver.class).toInstance(new KinesisHandleResolver(connectorName));

                    // Moved creation here from KinesisConnectorModule to make it easier to parameterize
                    if (altProviderClass.isPresent()) {
                        binder.bind(KinesisClientProvider.class).to(altProviderClass.get()).in(Scopes.SINGLetoN);
                    }
                    else {
                        binder.bind(KinesisClientProvider.class).to(KinesisClientManager.class).in(Scopes.SINGLetoN);
                    }

                    if (tableDescriptionsupplier.isPresent()) {
                        binder.bind(new TypeLiteral<supplier<Map<SchemaTableName,KinesisstreamDescription>>>() {}).toInstance(tableDescriptionsupplier.get());
                    }
                    else {
                        binder.bind(new TypeLiteral<supplier<Map<SchemaTableName,KinesisstreamDescription>>>() {}).to(KinesisTableDescriptionsupplier.class).in(Scopes.SINGLetoN);
                    }
                }
        );

        this.injector = app.strictConfig()
                    .donotinitializeLogging()
                    .setrequiredConfigurationProperties(config)
                    .setoptionalConfigurationProperties(optionalConfig)
                    .initialize();

        KinesisConnector connector = this.injector.getInstance(KinesisConnector.class);

        // Register objects for shutdown,at the moment only KinesisTableDescriptionsupplier
        if (!tableDescriptionsupplier.isPresent()) {
            // This will shutdown related dependent objects as well:
            KinesisTableDescriptionsupplier supp = getTableDescsupplier(this.injector);
            connector.registerShutdownObject(supp);
        }

        log.info("Done with injector.  Returning the connector itself.");
        return connector;
    }
    catch (Exception e) {
        throw Throwables.propagate(e);
    }
}