Java Code Examples for java.util.function.Function#identity()

@Test
public void doesntRetainObjectsWithForcedCancelOnSubscriber_conditional() {
	RetainedDetector retainedDetector = new RetainedDetector();
	AtomicReference<DistinctDefaultCancel> fooRef = new AtomicReference<>(retainedDetector.tracked(new DistinctDefaultCancel(0)));

	DistinctUntilChangedConditionalSubscriber<DistinctDefaultCancel, DistinctDefaultCancel> sub = new DistinctUntilChangedConditionalSubscriber<>(
			Operators.toConditionalSubscriber(new BaseSubscriber<DistinctDefaultCancel>() {}), Function.identity(), Objects::equals);
	sub.onSubscribe(Operators.emptySubscription());
	sub.onNext(fooRef.getAndSet(null));

	assertThat(retainedDetector.finalizedCount()).isZero();
	assertThat(retainedDetector.trackedTotal()).isOne();

	sub.cancel();
	System.gc();

	await()
			.atMost(2, TimeUnit.SECONDS)
			.untilAsserted(retainedDetector::assertAllFinalized);
}
 

@SuppressWarnings("unchecked")
static <K, D, A, M extends Map<K, D>> PartialCollector<Map<K, A>, M> grouping(Supplier<M> mapFactory,
        Collector<?, A, D> downstream) {
    BinaryOperator<A> downstreamMerger = downstream.combiner();
    BiConsumer<Map<K, A>, Map<K, A>> merger = (map1, map2) -> {
        for (Map.Entry<K, A> e : map2.entrySet())
            map1.merge(e.getKey(), e.getValue(), downstreamMerger);
    };

    if (downstream.characteristics().contains(Collector.Characteristics.IDENTITY_FINISH)) {
        return (PartialCollector<Map<K, A>, M>) new PartialCollector<>((Supplier<Map<K, A>>) mapFactory,
                merger, Function.identity(), ID_CHARACTERISTICS);
    }
    Function<A, D> downstreamFinisher = downstream.finisher();
    return new PartialCollector<>((Supplier<Map<K, A>>) mapFactory, merger, map -> {
        map.replaceAll((k, v) -> ((Function<A, A>) downstreamFinisher).apply(v));
        return (M) map;
    }, NO_CHARACTERISTICS);
}
 

@Test(timeout = 1000)
public void batcher_blocks_when_queue_is_full() throws Exception {
  Function<List<Integer>, List<Integer>> batchHandler = Function.identity();
  AtomicReference<Runnable> processQueue = new AtomicReference<>();
  ThreadFactory factory = r -> {
    processQueue.set(r);
    return new Thread();
  };

  CountDownLatch latch = new CountDownLatch(1);

  Thread thread = null;
  try (MessageBatcher<Integer, Integer> batcher = new MessageBatcher<>(4, 2, EnqueueBehaviour.BLOCK_AND_WAIT,
      batchHandler, factory)) {
    thread = new Thread(() -> {
      batcher.apply(1);
      batcher.apply(2);
      batcher.apply(3);
      batcher.apply(4);
      latch.countDown();
      batcher.apply(5);
    });
    thread.start();
    latch.await();

    while (thread.getState() != State.WAITING) {}
  } finally {
    if (thread != null) {
      thread.interrupt();
      thread.join();
    }
  }
}
 

/**
 * Verifies that getNormalCount() returns the number of issues with Severity#NORMAL.
 */
@Test
void shouldReturnNormalCountOne() {
    Report issues = new Report();
    IssueBuilder builder = new IssueBuilder();
    issues.add(builder.setSeverity(Severity.WARNING_NORMAL).setCategory(KEY).build());
    PropertyStatistics statistics = new PropertyStatistics(issues, "category", Function.identity());

    long value = statistics.getNormalCount(KEY);

    assertThat(value).isEqualTo(1);
}
 

private <P, V> void testGet(TestContext ctx, String sqlType, P param, V value, String column, Function<TestDataObject, V> getter) {
  super.testGet(
    ctx,
    sqlType,
    TestDataObjectRowMapper.INSTANCE,
    Function.identity(),
    "value",
    Collections.singletonMap("value", param),
    value,
    getter,
    column);
}
 

@Override
protected Sender sender() {
  return new Sender() {

    private ReadStreamSubscriber<String, String> subscriber = new ReadStreamSubscriber<>(Function.identity());

    {
      stream = subscriber;
      subscriber.onSubscribe(new Subscription() {
        @Override
        public void request(long n) {
          requested += n;
        }
        @Override
        public void cancel() {
        }
      });
    }

    protected void emit() {
      subscriber.onNext("" + seq++);
    }

    protected void complete() {
      subscriber.onComplete();
    }

    protected void fail(Throwable cause) {
      subscriber.onError(cause);
    }

  };
}
 

/**
 * Verifies that getNormalCount() returns zero if there are not issues with Severity#NORMAL.
 */
@Test
void shouldReturnNormalCountZero() {
    Report issues = new Report();
    IssueBuilder builder = new IssueBuilder();
    issues.add(builder.setSeverity(Severity.WARNING_LOW).setCategory(KEY).build());
    PropertyStatistics statistics = new PropertyStatistics(issues, "category", Function.identity());

    long value = statistics.getNormalCount(KEY);

    assertThat(value).isEqualTo(0);
}
 

protected Function<String, String> tryApplyLimit(OptionalLong limit)
{
    if (limit.isEmpty()) {
        return Function.identity();
    }
    return limitFunction()
            .map(limitFunction -> (Function<String, String>) sql -> limitFunction.apply(sql, limit.getAsLong()))
            .orElseGet(Function::identity);
}
 

private Function<String, String> getDateTransformFunction(CodeFragment fragment, EqlDateFormat dateFormat) {
	if (fragment.evaluatesToType(DataType.DATE)) {
		return x -> this.sqlDialect.dateToString(x, dateFormat);
	}

	if (fragment.evaluatesToType(DataType.TEXT)) {
		return x -> normalizeDateValue(dateFormat, x);
	}

	return Function.identity();
}
 

@Test
public void messages_fail_when_buffer_full() throws Exception {
  Function<List<Integer>, List<Integer>> batchHandler = Function.identity();
  AtomicReference<Runnable> processQueue = new AtomicReference<>();
  ThreadFactory factory = r -> {
    processQueue.set(r);
    return new Thread();
  };
  Thread t = null;
  try (MessageBatcher<Integer, Integer> batcher = new MessageBatcher<>(4, 2, EnqueueBehaviour.COMPLETE_EXCEPTIONALLY,
      batchHandler, factory)) {
    CompletableFuture<Integer> result1 = batcher.apply(1);
    CompletableFuture<Integer> result2 = batcher.apply(2);
    CompletableFuture<Integer> result3 = batcher.apply(3);
    CompletableFuture<Integer> result4 = batcher.apply(4);
    CompletableFuture<Integer> result5 = batcher.apply(5);

    t = new Thread(processQueue.get());
    t.start();

    assertThat(result1.get(), is(1));
    assertThat(result2.get(), is(2));
    assertThat(result3.get(), is(3));
    assertThat(result4.get(), is(4));

    try {
      result5.get();
      fail();
    } catch (ExecutionException e) {
      assertTrue(e.getCause() instanceof IllegalStateException);
    }
  }
  t.join();
}
 

private MerklePatriciaTrie<Bytes32, Bytes> createStateTrie(final Bytes32 rootHash) {
  return new StoredMerklePatriciaTrie<>(
      worldStateStorage::getAccountStateTrieNode,
      rootHash,
      Function.identity(),
      Function.identity());
}
 

private MerklePatriciaTrie<Bytes32, Bytes> createStorageTrie(final Bytes32 rootHash) {
  return new StoredMerklePatriciaTrie<>(
      worldStateStorage::getAccountStorageTrieNode,
      rootHash,
      Function.identity(),
      Function.identity());
}
 

public PropertyNamingStrategy create() {
    if (String.class.isInstance(value)) {
        final String val = value.toString();
        switch (val) {
            case PropertyNamingStrategy.IDENTITY:
                return propertyName -> propertyName;
            case PropertyNamingStrategy.LOWER_CASE_WITH_DASHES:
                return new ConfigurableNamingStrategy(Character::toLowerCase, '-');
            case PropertyNamingStrategy.LOWER_CASE_WITH_UNDERSCORES:
                return new ConfigurableNamingStrategy(Character::toLowerCase, '_');
            case PropertyNamingStrategy.UPPER_CAMEL_CASE:
                return camelCaseStrategy();
            case PropertyNamingStrategy.UPPER_CAMEL_CASE_WITH_SPACES:
                final PropertyNamingStrategy camelCase = camelCaseStrategy();
                final PropertyNamingStrategy space = new ConfigurableNamingStrategy(Function.identity(), ' ');
                return propertyName -> camelCase.translateName(space.translateName(propertyName));
            case PropertyNamingStrategy.CASE_INSENSITIVE:
                return propertyName -> propertyName;
            default:
                throw new IllegalArgumentException(val + " unknown as PropertyNamingStrategy");
        }
    }
    if (PropertyNamingStrategy.class.isInstance(value)) {
        return PropertyNamingStrategy.class.cast(value);
    }
    throw new IllegalArgumentException(value + " not supported as PropertyNamingStrategy");
}
 

@Override
public Function<Model, Model> finisher() {
	return Function.identity();
}
 

private BuildSideSetup setupBuildSide(
        boolean parallelBuild,
        TaskContext taskContext,
        List<Integer> hashChannels,
        RowPagesBuilder buildPages,
        Optional<InternalJoinFilterFunction> filterFunction,
        boolean spillEnabled,
        SingleStreamSpillerFactory singleStreamSpillerFactory)
{
    Optional<JoinFilterFunctionFactory> filterFunctionFactory = filterFunction
            .map(function -> (session, addresses, pages) -> new StandardJoinFilterFunction(function, addresses, pages));

    int partitionCount = parallelBuild ? PARTITION_COUNT : 1;
    LocalExchangeFactory localExchangeFactory = new LocalExchangeFactory(
            FIXED_HASH_DISTRIBUTION,
            partitionCount,
            buildPages.getTypes(),
            hashChannels,
            buildPages.getHashChannel(),
            UNGROUPED_EXECUTION,
            DataSize.of(32, DataSize.Unit.MEGABYTE));
    LocalExchangeSinkFactoryId localExchangeSinkFactoryId = localExchangeFactory.newSinkFactoryId();
    localExchangeFactory.noMoreSinkFactories();

    // collect input data into the partitioned exchange
    DriverContext collectDriverContext = taskContext.addPipelineContext(0, true, true, false).addDriverContext();
    ValuesOperatorFactory valuesOperatorFactory = new ValuesOperatorFactory(0, new PlanNodeId("values"), buildPages.build());
    LocalExchangeSinkOperatorFactory sinkOperatorFactory = new LocalExchangeSinkOperatorFactory(localExchangeFactory, 1, new PlanNodeId("sink"), localExchangeSinkFactoryId, Function.identity());
    Driver sourceDriver = Driver.createDriver(collectDriverContext,
            valuesOperatorFactory.createOperator(collectDriverContext),
            sinkOperatorFactory.createOperator(collectDriverContext));
    valuesOperatorFactory.noMoreOperators();
    sinkOperatorFactory.noMoreOperators();

    while (!sourceDriver.isFinished()) {
        sourceDriver.process();
    }

    // build side operator factories
    LocalExchangeSourceOperatorFactory sourceOperatorFactory = new LocalExchangeSourceOperatorFactory(0, new PlanNodeId("source"), localExchangeFactory);
    JoinBridgeManager<PartitionedLookupSourceFactory> lookupSourceFactoryManager = JoinBridgeManager.lookupAllAtOnce(new PartitionedLookupSourceFactory(
            buildPages.getTypes(),
            rangeList(buildPages.getTypes().size()).stream()
                    .map(buildPages.getTypes()::get)
                    .collect(toImmutableList()),
            hashChannels.stream()
                    .map(buildPages.getTypes()::get)
                    .collect(toImmutableList()),
            partitionCount,
            false));

    HashBuilderOperatorFactory buildOperatorFactory = new HashBuilderOperatorFactory(
            1,
            new PlanNodeId("build"),
            lookupSourceFactoryManager,
            rangeList(buildPages.getTypes().size()),
            hashChannels,
            buildPages.getHashChannel()
                    .map(OptionalInt::of).orElse(OptionalInt.empty()),
            filterFunctionFactory,
            Optional.empty(),
            ImmutableList.of(),
            100,
            new PagesIndex.TestingFactory(false),
            spillEnabled,
            singleStreamSpillerFactory);
    return new BuildSideSetup(lookupSourceFactoryManager, buildOperatorFactory, sourceOperatorFactory, partitionCount);
}
 

@Override
public Policy<K, V> policy() {
  return (policy == null)
      ? (policy = new BoundedPolicy<>(cache, Function.identity(), isWeighted))
      : policy;
}
 

@Override
protected Function<List<Row>, List<Row>> parentTypeToCurrentType() {
  return Function.identity();
}
 

@Override
protected Function<List<Row>, List<Row>> parentTypeToCurrentType() {
  return Function.identity();
}
 

public InMemoryPlaintextSecret(SecretsGroup secretsGroup, SecretIdentifier secretIdentifier) {
    super(secretsGroup, secretIdentifier, Function.identity());
}
 

@Test
public void testIdentity() {
	Function<String, String> function1 = Function.identity();
	Function<Integer, Integer> function2 = Function.identity();
	assertSame(function1, function2);
}