import java.io.OutputStream;

import org.junit.Test;

/**
 * @author shot
 */
public class CloseableUtilTest {

    /**
     * @throws Exception
     */
    @Test
    public void testClose() throws Exception {
        final NotifyOutputStream out = new NotifyOutputStream();
        CloseableUtil.close(out);
        assertThat(out.getNotify(), is("closed"));
    }

    /**
     * @throws Exception

        given:
        file("src/test/java/DisabledTest.java") << """
            @org.testng.annotations.Test(enabled = false)
            public class DisabledTest {
                public void testOne() {}
                public void testTwo() {}
            }
        """

        when:
        executer.expectDocumentedDeprecationWarning("No test executed. This behavior has been deprecated. " +

	})
}

// Execute this command sequence:
//
//	replace the word LINE with the line number < testdata/test.go > testdata/test_line.go
//	testcover -mode=count -var=CoverTest -o ./testdata/test_cover.go testdata/test_line.go
//	go run ./testdata/main.go ./testdata/test.go
func TestCover(t *testing.T) {
	testenv.MustHaveGoRun(t)
	t.Parallel()
	dir := tempDir(t)

  ASSERT_EQ(stream.str(), "0.375");
}

TEST(OStreamTest, TestString) {
  String s("foo");
  std::stringstream stream;
  stream << s;
  ASSERT_EQ(stream.str(), "foo");
}

TEST(OStreamTest, TestNone) {
  std::stringstream stream;
  stream << None::GetInstance();
  ASSERT_EQ(stream.str(), "None");
}

TEST(OStreamTest, TestTensorSpec) {
  std::stringstream stream;
  TensorSpec tensor_spec;

{
  "node": {
    "id": "{{ .EnvoyConfigOpt.NodeID }}",
    "cluster": "mycluster",
    "locality": {
      "zone": "testzone"
    },
    "metadata": {
      {{ .EnvoyConfigOpt.meta_json_str }}
    }
  },
  "stats_config": {
    "use_all_default_tags": false
  },
  "admin": {
    "access_log_path": "{{.AccessLogPath}}",
    "address": {
      "socket_address": {
        "address": "0.0.0.0",

        Date expected4 = new Date();
        doc.put("key4", expected4);
        assertEquals(expected4, DocumentUtil.getValue(doc, "key4", Date.class));
    }

    public void test_long() {
        Map<String, Object> doc = new HashMap<>();

        long expected5 = 999999999999999999L;
        doc.put("key5", expected5);

limitations under the License.
*/

package version

import (
	"fmt"
	"reflect"
	"testing"
)

type testItem struct {
	version    string
	unparsed   string
	equalsPrev bool
}

func testOne(v *Version, item, prev testItem) error {
	str := v.String()
	if item.unparsed == "" {
		if str != item.version {
			return fmt.Errorf("bad round-trip: %q -> %q", item.version, str)
		}
	} else {

	}
	textClone, err := t.text.Clone()
	if err != nil {
		return nil, err
	}
	ns := &nameSpace{set: make(map[string]*Template)}
	ns.esc = makeEscaper(ns)
	ret := &Template{
		nil,
		textClone,
		textClone.Tree,
		ns,
	}
	ret.set[ret.Name()] = ret
	for _, x := range textClone.Templates() {
		name := x.Name()
		src := t.set[name]

  }

  public void testInt() {
    TestHasher hasher = new TestHasher();
    hasher.putInt(0x04030201);
    hasher.assertBytes(new byte[] {1, 2, 3, 4});
  }

  public void testLong() {
    TestHasher hasher = new TestHasher();
    hasher.putLong(0x0807060504030201L);
    hasher.assertBytes(new byte[] {1, 2, 3, 4, 5, 6, 7, 8});
  }

  public void testChar() {

        buildFile << """
            repositories {
                maven { url '${server.uri}' }
            }
            configurations { compile }
            dependencies {
                compile "test:one:1.2"
                compile "test:two:1.2"
            }
            task resolve {
                def files = configurations.compile
                doLast {
                    files.each { println it.name }