test_class.declarator: topicName = "topic"
test_class.modifier: private
test_class.original_string: private String topicName = "topic";
test_class.type: String
test_class.var_name: topicName
test_class.declarator: intSerde = Serdes.Integer()
test_class.modifier: final private
test_class.original_string: final private Serde<Integer> intSerde = Serdes.Integer();
test_class.type: Serde<Integer>
test_class.var_name: intSerde
test_class.declarator: driver
test_class.modifier: private
test_class.original_string: private KStreamTestDriver driver;
test_class.type: KStreamTestDriver
test_class.var_name: driver
test_class.file: streams/src/test/java/org/apache/kafka/streams/kstream/internals/KStreamTransformTest.java
test_class.identifier: KStreamTransformTest
test_case.body: @Test
      public void testTransform() {
          KStreamBuilder builder = new KStreamBuilder();
  
          TransformerSupplier<Integer, Integer, KeyValue<Integer, Integer>> transformerSupplier =
              new TransformerSupplier<Integer, Integer, KeyValue<Integer, Integer>>() {
                  public Transformer<Integer, Integer, KeyValue<Integer, Integer>> get() {
                      return new Transformer<Integer, Integer, KeyValue<Integer, Integer>>() {
  
                          private int total = 0;
  
                          @Override
                          public void init(ProcessorContext context) {
                          }
  
                          @Override
                          public KeyValue<Integer, Integer> transform(Integer key, Integer value) {
                              total += value;
                              return KeyValue.pair(key * 2, total);
                          }
  
                          @Override
                          public KeyValue<Integer, Integer> punctuate(long timestamp) {
                              return KeyValue.pair(-1, (int) timestamp);
                          }
  
                          @Override
                          public void close() {
                          }
                      };
                  }
              };
  
          final int[] expectedKeys = {1, 10, 100, 1000};
  
          MockProcessorSupplier<Integer, Integer> processor = new MockProcessorSupplier<>();
          KStream<Integer, Integer> stream = builder.stream(intSerde, intSerde, topicName);
          stream.transform(transformerSupplier).process(processor);
  
          driver = new KStreamTestDriver(builder);
          for (int i = 0; i < expectedKeys.length; i++) {
              driver.process(topicName, expectedKeys[i], expectedKeys[i] * 10);
          }
  
          driver.punctuate(2);
          driver.punctuate(3);
  
          assertEquals(6, processor.processed.size());
  
          String[] expected = {"2:10", "20:110", "200:1110", "2000:11110", "-1:2", "-1:3"};
  
          for (int i = 0; i < expected.length; i++) {
              assertEquals(expected[i], processor.processed.get(i));
          }
      }
test_case.class_method_signature: KStreamTransformTest.testTransform()
test_case.full_signature: @Test public void testTransform()
test_case.identifier: testTransform
test_case.invocations: pair pair stream process transform process punctuate punctuate assertEquals size assertEquals get
test_case.modifiers: @Test public
test_case.parameters: ()
test_case.return: void
test_case.signature: void testTransform()
focal_class.declarator: transformerSupplier
focal_class.modifier: private final
focal_class.original_string: private final TransformerSupplier<K, V, KeyValue<K1, V1>> transformerSupplier;
focal_class.type: TransformerSupplier<K, V, KeyValue<K1, V1>>
focal_class.var_name: transformerSupplier
focal_class.file: streams/src/main/java/org/apache/kafka/streams/kstream/internals/KStreamTransform.java
focal_class.identifier: KStreamTransform
focal_class.interfaces: implements ProcessorSupplier<K, V>
focal_class.class_method_signature: KStreamTransform.KStreamTransform(TransformerSupplier<K, V, KeyValue<K1, V1>> transformerSupplier)
focal_class.full_signature: public  KStreamTransform(TransformerSupplier<K, V, KeyValue<K1, V1>> transformerSupplier)
focal_class.identifier: KStreamTransform
focal_class.modifiers: public
focal_class.parameters: (TransformerSupplier<K, V, KeyValue<K1, V1>> transformerSupplier)
focal_class.signature:  KStreamTransform(TransformerSupplier<K, V, KeyValue<K1, V1>> transformerSupplier)
focal_class.class_method_signature: KStreamTransform.get()
focal_class.full_signature: @Override public Processor<K, V> get()
focal_class.identifier: get
focal_class.modifiers: @Override public
focal_class.parameters: ()
focal_class.return: Processor<K, V>
focal_class.signature: Processor<K, V> get()
focal_method.body: @Override
      public Processor<K, V> get() {
          return new KStreamTransformProcessor<>(transformerSupplier.get());
      }
focal_method.class_method_signature: KStreamTransform.get()
focal_method.full_signature: @Override public Processor<K, V> get()
focal_method.identifier: get
focal_method.invocations: get
focal_method.modifiers: @Override public
focal_method.parameters: ()
focal_method.return: Processor<K, V>
focal_method.signature: Processor<K, V> get()