First commit

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/integration/TestDev.hx

@@ -0,0 +1,136 @@
+package tests.integration;
+
+import haxelib.*;
+import IntegrationTests.*;
+using IntegrationTests;
+import haxe.io.*;
+
+class TestDev extends IntegrationTests {
+	function testDev():Void {
+		{
+			var r = haxelib(["dev", "Bar", "test/libraries/libBar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertTrue(r.out.indexOf("Bar") >= 0);
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["path", "Bar"]).result();
+			var out = ~/\r?\n/g.split(r.out);
+			assertEquals(
+				Path.addTrailingSlash(Path.normalize(sys.FileSystem.fullPath("test/libraries/libBar"))),
+				Path.addTrailingSlash(Path.normalize(out[0]))
+			);
+			if (clientVer > SemVer.ofString("3.1.0-rc.4"))
+				assertEquals("-D Bar=1.0.0", out[1]);
+			else
+				assertEquals("-D Bar", out[1]);
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["remove", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") == -1);
+		}
+	}
+
+	function testWrongPath():Void {
+		{
+			var r = haxelib(["dev", "Bar", "test/libraries/libBar_not_exist"]).result();
+			// assertTrue(r.code != 0); //TODO
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			if (clientVer > SemVer.ofString("3.1.0-rc.4"))
+				assertTrue(r.out.indexOf("Bar") == -1);
+		}
+	}
+
+	function testNoHaxelibJson():Void {
+		{
+			var r = haxelib(["dev", "Bar", "bin"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+		}
+
+		{
+			var r = haxelib(["path", "Bar"]).result();
+			var out = ~/\r?\n/g.split(r.out);
+			assertEquals(
+				Path.addTrailingSlash(Path.normalize(sys.FileSystem.fullPath("bin"))),
+				Path.addTrailingSlash(Path.normalize(out[0]))
+			);
+			if (clientVer > SemVer.ofString("3.1.0-rc.4"))
+				assertEquals("-D Bar=0.0.0", out[1]);
+			else
+				assertEquals("-D Bar", out[1]);
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["remove", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") == -1);
+		}
+	}
+
+	function testClassPath():Void {
+		{
+			var r = haxelib(["dev", "UseCp", "test/libraries/UseCp"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "UseCp"]).result();
+			assertTrue(r.out.indexOf("UseCp") >= 0);
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["path", "UseCp"]).result();
+			var out = ~/\r?\n/g.split(r.out);
+			assertEquals(
+				Path.addTrailingSlash(Path.normalize(sys.FileSystem.fullPath("test/libraries/UseCp/lib/src"))),
+				Path.addTrailingSlash(Path.normalize(out[0]))
+			);
+			if (clientVer > SemVer.ofString("3.1.0-rc.4"))
+				assertEquals("-D UseCp=0.0.1", out[1]);
+			else
+				assertEquals("-D UseCp", out[1]);
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["remove", "UseCp"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "UseCp"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("UseCp") == -1);
+		}
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/integration/TestEmpty.hx

@@ -0,0 +1,78 @@
+package tests.integration;
+
+import haxe.*;
+import haxe.io.*;
+import haxelib.*;
+import IntegrationTests.*;
+using IntegrationTests;
+
+class TestEmpty extends IntegrationTests {
+	function testEmpty():Void {
+		// the initial local and remote repos are empty
+
+		var installResult = haxelib(["install", "foo"]).result();
+		assertTrue(installResult.code != 0);
+
+		var upgradeResult = haxelib(["upgrade"]).result();
+		assertSuccess(upgradeResult);
+
+		var updateResult = haxelib(["update", "foo"]).result();
+		// assertTrue(updateResult.code != 0);
+
+		var removeResult = haxelib(["remove", "foo"]).result();
+		assertTrue(removeResult.code != 0);
+
+		var upgradeResult = haxelib(["list"]).result();
+		assertSuccess(upgradeResult);
+
+		var removeResult = haxelib(["set", "foo", "0.0"], "y\n").result();
+		assertTrue(removeResult.code != 0);
+
+		var searchResult = haxelib(["search", "foo"]).result();
+		assertSuccess(searchResult);
+		assertTrue(searchResult.out.indexOf("0") >= 0);
+
+		var infoResult = haxelib(["info", "foo"]).result();
+		assertTrue(infoResult.code != 0);
+
+		var userResult = haxelib(["user", "foo"]).result();
+		assertTrue(userResult.code != 0);
+
+		var configResult = haxelib(["config"]).result();
+		assertSuccess(configResult);
+
+		var pathResult = haxelib(["path", "foo"]).result();
+		assertTrue(pathResult.code != 0);
+
+		if (clientVer > SemVer.ofString("3.1.0-rc.4")) {
+			var versionResult = haxelib(["version"]).result();
+			assertSuccess(versionResult);
+
+			var helpResult = haxelib(["help"]).result();
+			assertSuccess(helpResult);
+		}
+	}
+
+	function testWebsite():Void {
+		// home page
+		assertNoError(function() Http.requestUrl(serverUrl));
+
+		// Haxelib Tags
+		assertNoError(function() Http.requestUrl(Path.join([serverUrl, "t"])));
+
+		// All Haxelibs
+		assertNoError(function() Http.requestUrl(Path.join([serverUrl, "all"])));
+
+		// Haxelib Contributors
+		assertNoError(function() Http.requestUrl(Path.join([serverUrl, "u"])));
+
+		// docs
+		assertNoError(function() Http.requestUrl(Path.join([serverUrl, "documentation"])));
+		assertNoError(function() Http.requestUrl(Path.join([serverUrl, "documentation/using-haxelib"])));
+		assertNoError(function() Http.requestUrl(Path.join([serverUrl, "documentation/creating-a-haxelib-package/"])));
+		assertNoError(function() Http.requestUrl(Path.join([serverUrl, "documentation/creating-a-haxelib-package/"])));
+
+		// RSS feed
+		assertNoError(function() Http.requestUrl(Path.join([serverUrl, "rss"])));
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/integration/TestInfo.hx

@@ -0,0 +1,66 @@
+package tests.integration;
+
+import IntegrationTests.*;
+using IntegrationTests;
+
+class TestInfo extends IntegrationTests {
+	function test():Void {
+		{
+			var r = haxelib(["register", bar.user, bar.email, bar.fullname, bar.pw, bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["info", "Bar"]).result();
+			assertSuccess(r);
+
+			assertTrue(r.out.indexOf("Bar") >= 0);
+
+			// license
+			assertTrue(r.out.indexOf("GPL") >= 0);
+
+			// tags
+			assertTrue(r.out.indexOf("bar") >= 0);
+			assertTrue(r.out.indexOf("test") >= 0);
+
+			// versions
+			assertTrue(r.out.indexOf("1.0.0") >= 0);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar2.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["info", "Bar"]).result();
+			assertSuccess(r);
+
+			assertTrue(r.out.indexOf("Bar") >= 0);
+
+			// license
+			assertTrue(r.out.indexOf("MIT") >= 0);
+
+			// tags
+			assertTrue(r.out.indexOf("bar") >= 0);
+			assertTrue(r.out.indexOf("test") == -1);
+			assertTrue(r.out.indexOf("version2") >= 0);
+
+			// versions
+			assertTrue(r.out.indexOf("1.0.0") >= 0);
+			assertTrue(r.out.indexOf("2.0.0") >= 0);
+		}
+	}
+
+	function testNotExist():Void {
+		{
+			var r = haxelib(["info", "Bar"]).result();
+			assertTrue(r.code != 0);
+		}
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/integration/TestList.hx

@@ -0,0 +1,116 @@
+package tests.integration;
+
+import haxelib.*;
+import IntegrationTests.*;
+using IntegrationTests;
+
+class TestList extends IntegrationTests {
+	function test():Void {
+		{
+			var r = haxelib(["list"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["register", bar.user, bar.email, bar.fullname, bar.pw, bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["install", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+			assertTrue(r.out.indexOf("[1.0.0]") >= 0);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar2.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["update", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+			var pos1 = r.out.indexOf("1.0.0");
+			var pos2 = r.out.indexOf("2.0.0");
+			assertTrue(pos1 >= 0);
+			assertTrue(pos2 >= 0);
+
+			if (SemVer.compare(clientVer, SemVer.ofString("3.3.0")) >= 0) {
+				assertTrue(pos2 >= pos1);
+			}
+		}
+	}
+
+	/**
+		Make sure the version list is in ascending order, independent of the installation order.
+	**/
+	function testInstallNewThenOld():Void {
+		{
+			var r = haxelib(["register", bar.user, bar.email, bar.fullname, bar.pw, bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar2.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["install", "Bar", "2.0.0"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["install", "Bar", "1.0.0"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+			var pos1 = r.out.indexOf("1.0.0");
+			var pos2 = r.out.indexOf("2.0.0");
+			assertTrue(pos1 >= 0);
+			assertTrue(pos2 >= 0);
+
+			if (SemVer.compare(clientVer, SemVer.ofString("3.3.0")) >= 0) {
+				assertTrue(pos2 >= pos1);
+			}
+		}
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/integration/TestSet.hx

@@ -0,0 +1,77 @@
+package tests.integration;
+
+import IntegrationTests.*;
+using IntegrationTests;
+using StringTools;
+
+class TestSet extends IntegrationTests {
+	function test():Void {
+		{
+			var r = haxelib(["register", bar.user, bar.email, bar.fullname, bar.pw, bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar2.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["search", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+		}
+
+		{
+			var r = haxelib(["install", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("[2.0.0]") >= 0);
+		}
+
+		{
+			var r = haxelib(["install", "Bar", "1.0.0"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("[2.0.0]") >= 0);
+			assertTrue(r.out.indexOf("1.0.0") >= 0);
+		}
+
+		{
+			var r = haxelib(["set", "Bar", "1.0.0"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("[1.0.0]") >= 0);
+			assertTrue(r.out.indexOf("2.0.0") >= 0);
+		}
+
+		{
+			var r = haxelib(["set", "Bar", "2.0.0"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("1.0.0") >= 0);
+			assertTrue(r.out.indexOf("[2.0.0]") >= 0);
+		}
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/integration/TestSimple.hx

@@ -0,0 +1,91 @@
+package tests.integration;
+
+import IntegrationTests.*;
+using IntegrationTests;
+
+class TestSimple extends IntegrationTests {
+	function testNormal():Void {
+		{
+			var r = haxelib(["register", bar.user, bar.email, bar.fullname, bar.pw, bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["search", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+		}
+
+		{
+			var r = haxelib(["register", foo.user, foo.email, foo.fullname, foo.pw, foo.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libFoo.zip", foo.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["search", "Foo"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Foo") >= 0);
+		}
+
+		{
+			var r = haxelib(["install", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["install", "Foo"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertTrue(r.out.indexOf("Bar") >= 0);
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Foo"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Foo") >= 0);
+		}
+
+		{
+			var r = haxelib(["list"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Foo") >= 0);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+		}
+
+		{
+			var r = haxelib(["remove", "Foo"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Foo"]).result();
+			assertTrue(r.out.indexOf("Foo") < 0);
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["remove", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") < 0);
+		}
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/integration/TestUpdate.hx

@@ -0,0 +1,69 @@
+package tests.integration;
+
+import IntegrationTests.*;
+using IntegrationTests;
+using StringTools;
+
+class TestUpdate extends IntegrationTests {
+	function test():Void {
+		{
+			var r = haxelib(["register", bar.user, bar.email, bar.fullname, bar.pw, bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["search", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+		}
+
+		{
+			var r = haxelib(["install", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["update", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("[1.0.0]") >= 0);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar2.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["update", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("[2.0.0]") >= 0);
+			assertTrue(r.out.indexOf("1.0.0") >= 0);
+		}
+
+		{
+			var r = haxelib(["remove", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") < 0);
+		}
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/integration/TestUpgrade.hx

@@ -0,0 +1,79 @@
+package tests.integration;
+
+import IntegrationTests.*;
+using IntegrationTests;
+using StringTools;
+
+class TestUpgrade extends IntegrationTests {
+	function test():Void {
+		{
+			var r = haxelib(["upgrade"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["register", bar.user, bar.email, bar.fullname, bar.pw, bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["search", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") >= 0);
+		}
+
+		{
+			var r = haxelib(["install", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("[1.0.0]") >= 0);
+		}
+
+		{
+			var r = haxelib(["upgrade"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/libBar2.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["upgrade"], "y\n").result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("[2.0.0]") >= 0);
+			assertTrue(r.out.indexOf("1.0.0") >= 0);
+		}
+
+		{
+			var r = haxelib(["upgrade"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["remove", "Bar"]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["list", "Bar"]).result();
+			assertSuccess(r);
+			assertTrue(r.out.indexOf("Bar") < 0);
+		}
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/integration/TestUser.hx

@@ -0,0 +1,49 @@
+package tests.integration;
+
+import IntegrationTests.*;
+using IntegrationTests;
+
+class TestUser extends IntegrationTests {
+	function test():Void {
+		{
+			var r = haxelib(["register", bar.user, bar.email, bar.fullname, bar.pw, bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["user", "Bar"]).result();
+			assertSuccess(r);
+
+			assertTrue(r.out.indexOf("Bar") >= 0);
+
+			assertTrue(r.out.indexOf(bar.email) >= 0);
+			assertTrue(r.out.indexOf(bar.fullname) >= 0);
+			assertTrue(r.out.indexOf(bar.pw) == -1);
+		}
+
+		{
+			var r = haxelib(["submit", "test/libraries/UseCp.zip", bar.pw]).result();
+			assertSuccess(r);
+		}
+
+		{
+			var r = haxelib(["user", "Bar"]).result();
+			assertSuccess(r);
+
+			assertTrue(r.out.indexOf("Bar") >= 0);
+
+			assertTrue(r.out.indexOf(bar.email) >= 0);
+			assertTrue(r.out.indexOf(bar.fullname) >= 0);
+			assertTrue(r.out.indexOf(bar.pw) == -1);
+
+			assertTrue(r.out.indexOf("UseCp") >= 0);
+		}
+	}
+
+	function testNotExist():Void {
+		{
+			var r = haxelib(["user", "Bar"]).result();
+			assertTrue(r.code != 0);
+		}
+	}
+}