@Override
            public OptionalEntity<WebConfig> getWebConfig(final String id) {
                final WebConfig webConfig = new WebConfig();
                webConfig.setId(id);
                if (id.endsWith("P")) {
                    webConfig.setConfigParameter("config.pipeline=wp");
                }
                return OptionalEntity.of(webConfig);
            }

    assertThat(readFully(reader)).isEqualTo(string);
    assertFullyRead(reader);

    // reset and read again
    reader.reset();
    assertThat(readFully(reader)).isEqualTo(string);
    assertFullyRead(reader);

    // reset, skip, mark, then read the rest
    reader.reset();
    assertEquals(5, reader.skip(5));
    reader.mark(Integer.MAX_VALUE);

    Range(&vals, 0, num_dims_out);
    AbstractTensorHandle* sum_dims_raw = nullptr;
    TF_RETURN_IF_ERROR(TestTensorHandleWithDims<int32_t, TF_INT32>(
        ctx, vals.data(), vals_shape, 1, &sum_dims_raw));
    sum_dims.reset(sum_dims_raw);
  }

  // Reduce sum the output on all dimensions.
  TF_RETURN_IF_ERROR(ops::Sum(ctx, model_out.get(), sum_dims.get(), &outputs[0],
                              /*keep_dims=*/false, "sum_output"));

    }

    @Test
    @DisplayName("Test reset functionality")
    void testReset() {
        // Reset should not throw exception
        assertDoesNotThrow(() -> transaction.reset());

        // Transaction should be ready for reuse
        assertTrue(transaction.hasMoreElements());
    }

    @Test
    @DisplayName("Test reset with key and lastName")
    void testResetWithKeyAndLastName() {

  // Assign to the variable, copying to the custom device.
  std::unique_ptr<TFE_TensorHandle, decltype(&TFE_DeleteTensorHandle)> one(
      TestScalarTensorHandle(context.get(), 111.f), TFE_DeleteTensorHandle);
  op.reset(TFE_NewOp(context.get(), "AssignVariableOp", status.get()));
  TFE_OpSetAttrType(op.get(), "dtype", TF_FLOAT);
  TFE_OpAddInput(op.get(), var_handle, status.get());
  TFE_OpAddInput(op.get(), one.get(), status.get());

package jstream

import (
	"unicode/utf8"
)

type scratch struct {
	data []byte
	fill int
}

// reset scratch buffer
func (s *scratch) reset() { s.fill = 0 }

// bytes returns the written contents of scratch buffer
func (s *scratch) bytes() []byte { return s.data[0:s.fill] }

// grow scratch buffer
func (s *scratch) grow() {
	ndata := make([]byte, cap(s.data)*2)
	copy(ndata, s.data)
	s.data = ndata
}

				}(set)
			}
			wg.Wait()
		case <-staleUploadsCleanupIntervalChangedCh:
		}

		// Reset for the next interval
		timer.Reset(globalAPIConfig.getStaleUploadsCleanupInterval())
	}
}

type auditObjectOp struct {
	Name string `json:"name"`
	Pool int    `json:"poolId"`
	Set  int    `json:"setId"`
}

func (op auditObjectOp) String() string {
	// Flatten the auditObjectOp

        // Reset error and test hasMore flag
        response.setTestErrorCode(0);
        response.hasMore = false;
        assertFalse(response.hasMoreElements());
    }

    @Test
    @DisplayName("Test reset functionality")
    void testReset() {
        // Reset should not throw exception
        assertDoesNotThrow(() -> response.reset());
    }

    @Test

            final GetResponse getResponse = client.prepareGet().setIndex(index).setId(item.getId()).get(settings.getIndexTimeout());
            if (update && getResponse.isExists()) {
                final IndexRequestBuilder indexRequestBuilder = new IndexRequestBuilder(client, IndexAction.INSTANCE, index);
                indexRequestBuilder.setId(item.getId())
                        .setOpType(IndexRequest.OpType.INDEX)

        final CrawlingInfo info = new CrawlingInfo();
        info.setId("test-id");
        info.setSessionId("test-session");

        final String str = info.toString();
        assertNotNull(str);
    }

    @Test
    public void test_crawlingInfoParam_toString() {
        final CrawlingInfoParam param = new CrawlingInfoParam();
        param.setId("param-id");
        param.setKey("test-key");