First commit

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/TestData.hx

@@ -0,0 +1,282 @@
+package tests;
+
+import haxe.ds.StringMap;
+import haxe.Json;
+import haxe.io.*;
+import haxe.zip.*;
+import sys.io.*;
+import haxelib.Data;
+using StringTools;
+
+class TestData extends TestBase {
+
+	public function testSafe() {
+		assertEquals( "abc", checkSafe("abc") );
+		assertEquals( "bean,hx", checkSafe("bean.hx") );
+		assertEquals( "1,2,3", checkSafe("1.2.3") );
+		assertEquals( "_-,123", checkSafe("_-.123") );
+		assertEquals( "invalid", checkSafe("1,2") );
+		assertEquals( "invalid", checkSafe("space ") );
+		assertEquals( "invalid", checkSafe("\t") );
+		assertEquals( "invalid", checkSafe("\n") );
+		assertEquals( "invalid", checkSafe("") );
+	}
+
+	function checkSafe( str:String ) {
+		return try {
+			Data.safe( str );
+		} catch (e:String) "invalid";
+	}
+
+	public function testUnsafe() {
+		assertEquals( "abc", Data.unsafe("abc") );
+		assertEquals( "1.2.3", Data.unsafe("1,2,3") );
+		assertEquals( "", Data.unsafe("") );
+	}
+
+	public function testFileName() {
+		assertEquals( "lib-1,2,3.zip", checkFileName("lib","1.2.3") );
+		assertEquals( "lib-1,2,3-rc,3.zip", checkFileName("lib","1.2.3-rc.3") );
+		assertEquals( "invalid", checkFileName("lib",",") );
+		assertEquals( "invalid", checkFileName(",","version") );
+		assertEquals( "invalid", checkFileName("","version") );
+	}
+
+	function checkFileName( lib, ver ) {
+		return try {
+			Data.fileName( lib, ver );
+		} catch (e:String) "invalid";
+	}
+
+	public function testLocateBasePath() {
+		var zip = Reader.readZip(new BytesInput(File.getBytes("package.zip")));
+		assertEquals( "", Data.locateBasePath(zip) );
+
+		var zip = Reader.readZip(new BytesInput(File.getBytes("test/libraries/libDeep.zip")));
+		assertEquals( "libDeep/", Data.locateBasePath(zip) );
+	}
+
+	public function testReadDoc() {
+		var zip = Reader.readZip(new BytesInput(File.getBytes("package.zip")));
+		assertEquals( null, Data.readDoc(zip) );
+
+		//TODO
+	}
+
+	public function testReadInfos() {
+		var zip = Reader.readZip(new BytesInput(File.getBytes("package.zip")));
+		var info = Data.readInfos(zip, true);
+		assertEquals( "haxelib", info.name );
+		assertEquals( "GPL", info.license );
+
+		var zip = Reader.readZip(new BytesInput(File.getBytes("test/libraries/libDeep.zip")));
+		var info = Data.readInfos(zip, true);
+		assertEquals( "Deep", info.name );
+		assertEquals( "http://example.org", info.url );
+		assertEquals( "Public", info.license );
+		assertEquals( "deep, test", info.tags.join(", ") );
+		assertEquals( "This project's zip contains a folder that holds the lib.", info.description );
+		assertEquals( "1.0.0", info.version );
+		assertEquals( "N/A", info.releasenote );
+		assertEquals( "DeepAuthor, AnotherGuy", info.contributors.join(", ") );
+	}
+
+	public function testCheckClassPath() {
+		var zip = Reader.readZip(new BytesInput(File.getBytes("package.zip")));
+		var info = Data.readInfos(zip, true);
+		var ok:Dynamic = try {
+			Data.checkClassPath(zip,info);
+			true;
+		} catch (e:Dynamic) {
+			e;
+		}
+		assertEquals( ok, true );
+
+		var zip = Reader.readZip(new BytesInput(File.getBytes("test/libraries/libDeep.zip")));
+		var info = Data.readInfos(zip, true);
+		var ok:Dynamic = try {
+			Data.checkClassPath(zip,info);
+			true;
+		} catch (e:Dynamic) {
+			e;
+		}
+		assertEquals( ok, true );
+	}
+
+	public function testReadDataWithCheck() {
+		assertFalse( readDataOkay("bad json") );
+
+		assertTrue( readDataOkay(getJsonInfos()) );
+
+		// Names
+		assertFalse( readDataOkay("{}") );
+		assertFalse( readDataOkay(getJsonInfos({ name: null })) );
+
+		assertFalse( readDataOkay(getJsonInfos({ name: '' })) );
+		assertFalse( readDataOkay(getJsonInfos({ name: 'haxe' })) );
+		assertFalse( readDataOkay(getJsonInfos({ name: 'haXe' })) );
+		assertFalse( readDataOkay(getJsonInfos({ name: 'all' })) );
+		assertFalse( readDataOkay(getJsonInfos({ name: 'something.zip' })) );
+		assertFalse( readDataOkay(getJsonInfos({ name: 'something.hxml' })) );
+		assertFalse( readDataOkay(getJsonInfos({ name: '12' })) );
+		assertTrue( readDataOkay(getJsonInfos({ name: 'mylib' })) );
+		assertFalse( readDataOkay(getJsonInfos([ "name" ])) ); // remove the field altogether
+
+		// Description (optional)
+		assertTrue( readDataOkay(getJsonInfos({ description: 'Some Description' })) );
+		assertTrue( readDataOkay(getJsonInfos({ description: '' })) );
+		assertTrue( readDataOkay(getJsonInfos({ description: null })) );
+
+		// Licence
+		assertTrue( readDataOkay(getJsonInfos({ license: 'BSD' })) );
+		assertFalse( readDataOkay(getJsonInfos({ license: null })) );
+		assertFalse( readDataOkay(getJsonInfos({ license: '' })) );
+		assertFalse( readDataOkay(getJsonInfos({ license: 'CustomLicence' })) );
+		assertFalse( readDataOkay(getJsonInfos([ "license" ])) ); // remove the field altogether
+
+		// Contibutors
+		assertFalse( readDataOkay(getJsonInfos({ contributors: [] })) );
+		assertFalse( readDataOkay(getJsonInfos({ contributors: null })) );
+		assertFalse( readDataOkay(getJsonInfos({ contributors: "jason" })) );
+		assertTrue( readDataOkay(getJsonInfos({ contributors: ["jason"] })) );
+		assertTrue( readDataOkay(getJsonInfos({ contributors: ["jason","juraj"] })) );
+		assertFalse( readDataOkay(getJsonInfos([ "contributors" ])) ); // remove the field altogether
+
+		// Version
+		assertTrue( readDataOkay(getJsonInfos({ version: "0.1.2-rc.0" })) );
+		assertFalse( readDataOkay(getJsonInfos({ version: "non-semver" })) );
+		assertFalse( readDataOkay(getJsonInfos({ version: 0 })) );
+		assertFalse( readDataOkay(getJsonInfos({ version: null })) );
+		assertFalse( readDataOkay(getJsonInfos([ "version" ])) ); // remove the field altogether
+
+		// Tags (optional)
+		assertTrue( readDataOkay(getJsonInfos({ tags: ["tag1","tag2"] })) );
+		assertTrue( readDataOkay(getJsonInfos({ tags: null })) );
+		assertFalse( readDataOkay(getJsonInfos({ tags: "mytag" })) );
+
+		// Dependencies (optional)
+		assertTrue( readDataOkay(getJsonInfos({ dependencies: null })) );
+		assertTrue( readDataOkay(getJsonInfos({ dependencies: { somelib: "" } })) );
+
+		assertTrue( readDataOkay(getJsonInfos({ dependencies: { somelib:"1.3.0" } }) ));
+		assertFalse( readDataOkay(getJsonInfos({ dependencies: { somelib: "nonsemver" }})) );
+
+		assertFalse( readDataOkay(getJsonInfos({ dependencies: { somelib: 0 } })) );
+		assertFalse( readDataOkay(getJsonInfos({ dependencies: "somelib" })) );
+
+		// ReleaseNote
+		assertTrue( readDataOkay(getJsonInfos({ releasenote: "release" })) );
+		assertFalse( readDataOkay(getJsonInfos({ releasenote: ["some","note"] })) );
+		assertFalse( readDataOkay(getJsonInfos({ releasenote: null })) );
+		assertFalse( readDataOkay(getJsonInfos([ "releasenote" ])) ); // remove the field altogether
+
+		// ClassPath
+		assertTrue( readDataOkay(getJsonInfos({ classPath: 'src/' })) );
+		assertTrue( readDataOkay(getJsonInfos({ classPath: '' })) );
+		assertTrue( readDataOkay(getJsonInfos({ classPath: null })) );
+		assertFalse( readDataOkay(getJsonInfos({ classPath: ["src","othersrc"] })) );
+	}
+
+	public function testReadDataWithoutCheck() {
+		assertEquals( ProjectName.DEFAULT, Data.readData("bad json",false).name );
+		assertEquals( "0.0.0", Data.readData("bad json",false).version );
+
+		assertEquals( "mylib", Data.readData(getJsonInfos(),false).name );
+		assertEquals( "0.1.2", Data.readData(getJsonInfos(),false).version );
+
+		// Names
+		assertEquals( ProjectName.DEFAULT, Data.readData("{}",false).name );
+		assertEquals( ProjectName.DEFAULT, Data.readData(getJsonInfos({ name: null }),false).name );
+		assertEquals( ProjectName.DEFAULT, Data.readData(getJsonInfos({ name: '' }),false).name );
+		assertEquals( "mylib", Data.readData(getJsonInfos({ name: 'mylib' }),false).name );
+		assertEquals( ProjectName.DEFAULT, Data.readData(getJsonInfos([ "name" ]), false).name ); // remove the field altogether
+
+		/*
+		// Description (optional)
+		assertEquals( "Some Description", Data.readData(getJsonInfos({ description: 'Some Description' }),false).description );
+		assertEquals( "", Data.readData(getJsonInfos({ description: '' }),false).description );
+		assertEquals( "", Data.readData(getJsonInfos({ description: null }),false).description );
+		assertEquals( "", Data.readData(getJsonInfos([ "description" ]),false).description ); // remove the field altogether
+
+		// Licence
+		assertEquals( "BSD", Data.readData(getJsonInfos({ license: 'BSD' }),false).license );
+		assertEquals( "Unknown", Data.readData(getJsonInfos({ license: null }),false).license );
+		assertEquals( "Unknown", Data.readData(getJsonInfos({ license: '' }),false).license );
+		assertEquals( "CustomLicence", Data.readData(getJsonInfos({ license: 'CustomLicence' }),false).license );
+		assertEquals( "Unknown", Data.readData(getJsonInfos([ "license" ]),false).license ); // remove the field altogether
+
+		// Contibutors
+		assertEquals( 0, Data.readData(getJsonInfos({ contributors: [] }),false).contributors.length );
+		assertEquals( 0, Data.readData(getJsonInfos({ contributors: null }),false).contributors.length );
+		assertEquals( 0, Data.readData(getJsonInfos({ contributors: "jason" }),false).contributors.length );
+		assertEquals( 1, Data.readData(getJsonInfos({ contributors: ["jason"] }),false).contributors.length );
+		assertEquals( 2, Data.readData(getJsonInfos({ contributors: ["jason","juraj"] }),false).contributors.length );
+		assertEquals( 0, Data.readData(getJsonInfos([ "contributors" ]),false).contributors.length ); // remove the field altogether
+		*/
+		// Version
+		assertEquals( "0.1.2-rc.0", Data.readData(getJsonInfos({ version: "0.1.2-rc.0" }),false).version );
+		assertEquals( "0.0.0", Data.readData(getJsonInfos({ version: "non-semver" }),false).version );
+		assertEquals( "0.0.0", Data.readData(getJsonInfos({ version: 0 }),false).version );
+		assertEquals( "0.0.0", Data.readData(getJsonInfos({ version: null }),false).version );
+		assertEquals( "0.0.0", Data.readData(getJsonInfos([ "version" ]),false).version ); // remove the field altogether
+
+		/*
+		// Tags (optional)
+		assertEquals( 2, Data.readData(getJsonInfos({ tags: ["tag1","tag2"] }),false).tags.length );
+		assertEquals( 0, Data.readData(getJsonInfos({ tags: null }),false).tags.length );
+		assertEquals( 0, Data.readData(getJsonInfos({ tags: "mytag" }),false).tags.length );
+		*/
+
+		// Dependencies (optional)
+		assertEquals( 0, Data.readData(getJsonInfos({ dependencies: null }),false).dependencies.toArray().length );
+		assertEquals( "somelib", Data.readData(getJsonInfos({ dependencies: { somelib:"" } }),false).dependencies.toArray()[0].name );
+		assertEquals( "", Data.readData(getJsonInfos({ dependencies: { somelib:"" } }),false).dependencies.toArray()[0].version );
+		assertEquals( "1.3.0", Data.readData(getJsonInfos({ dependencies: { somelib:"1.3.0" } }),false).dependencies.toArray()[0].version );
+		assertEquals( "", Data.readData(getJsonInfos({ dependencies: { somelib:"nonsemver" } }),false).dependencies.toArray()[0].version );
+		assertEquals( "", Data.readData(getJsonInfos({ dependencies: { somelib:null } }),false).dependencies.toArray()[0].version );
+		assertEquals( "", Data.readData(getJsonInfos( { dependencies: { somelib:0 } } ), false).dependencies.toArray()[0].version );
+
+		/*
+		// ReleaseNote
+		assertEquals( "release", Data.readData(getJsonInfos({ releasenote: "release" }),false).releasenote );
+		assertEquals( "", Data.readData(getJsonInfos({ releasenote: null }),false).releasenote );
+		assertEquals( "", Data.readData(getJsonInfos([ "releasenote" ]),false).releasenote ); // remove the field altogether
+		*/
+		// ClassPath
+		assertEquals( "src", Data.readData(getJsonInfos({ classPath: 'src' }), false).classPath );
+		assertEquals( "", Data.readData(getJsonInfos({ classPath: '' }), false).classPath );
+		assertEquals( "", Data.readData(getJsonInfos({ classPath: null }), false).classPath );
+	}
+
+	function readDataOkay( json ) {
+		try {
+			Data.readData( json,true );
+			return true;
+		}
+		catch (e:String) {
+			return false;
+		}
+	}
+
+	function getJsonInfos( ?remove:Array<String>, ?change:Dynamic ) {
+		var infos = {
+			name: "mylib",
+			license: "MIT",
+			contributors: ["jason"],
+			version: "0.1.2",
+			releasenote: ""
+		};
+		if (change != null) {
+			for ( name in Reflect.fields(change) ) {
+				var value = Reflect.field( change, name );
+				Reflect.setField( infos, name, value );
+			}
+		}
+		if (remove != null) {
+			for ( f in remove )
+				Reflect.deleteField( infos, f );
+		}
+		return Json.stringify(infos);
+	}
+
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/TestGit.hx

@@ -0,0 +1,9 @@
+package tests;
+
+import haxelib.client.Vcs;
+
+class TestGit extends TestVcs {
+	public function new():Void {
+		super(VcsID.Git, "Git", "https://github.com/fzzr-/hx.signal.git", "0.9.2");
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/TestHg.hx

@@ -0,0 +1,9 @@
+package tests;
+
+import haxelib.client.Vcs;
+
+class TestHg extends TestVcs {
+	public function new():Void {
+		super(VcsID.Hg, "Mercurial", "https://bitbucket.org/fzzr/hx.signal", "78edb4b");
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/TestRemoveSymlinks.hx

@@ -0,0 +1,55 @@
+package tests;
+
+import sys.FileSystem;
+import sys.io.*;
+import haxe.io.Path;
+import haxe.unit.TestCase;
+
+class TestRemoveSymlinks extends TestBase
+{
+	//----------- properties, fields ------------//
+
+	static var REPO = "haxelib-repo";
+	var lib:String = "symlinks";
+	var repo:String = null;
+	var origRepo:String;
+
+	//--------------- constructor ---------------//
+	public function new()
+	{
+		super();
+		this.repo = Path.join([Sys.getCwd(), "test", REPO]);
+	}
+
+	//--------------- initialize ----------------//
+
+	override public function setup():Void
+	{
+		origRepo = ~/\r?\n/.split(runHaxelib(["config"]).stdout)[0];
+		origRepo = Path.normalize(origRepo);
+
+		var libzip = Path.join([Sys.getCwd(), "test", "libraries", lib + ".zip"]);
+		if (runHaxelib(["setup", repo]).exitCode != 0) {
+			throw "haxelib setup failed";
+		}
+		if (runHaxelib(["local", libzip]).exitCode != 0) {
+			throw "haxelib local failed";
+		}
+	}
+
+	override public function tearDown():Void {
+		if (runHaxelib(["setup", origRepo]).exitCode != 0) {
+			throw "haxelib setup failed";
+		}
+		deleteDirectory(repo);
+	}
+
+	//----------------- tests -------------------//
+
+	public function testRemoveLibWithSymlinks():Void
+	{
+		var code = runHaxelib(["remove", lib]).exitCode;
+		assertEquals(code, 0);
+		assertFalse(FileSystem.exists(Path.join([repo, lib])));
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/TestRemoveSymlinksBroken.hx

@@ -0,0 +1,9 @@
+package tests;
+
+class TestRemoveSymlinksBroken extends TestRemoveSymlinks
+{
+	public function new():Void {
+		super();
+		this.lib = "symlinks-broken";
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/TestSemVer.hx

@@ -0,0 +1,72 @@
+package tests;
+
+import haxelib.SemVer;
+
+class TestSemVer extends TestBase {
+	static function make(major, minor, patch, ?preview, ?previewNum):SemVer {
+		return {
+			major : major,
+			minor : minor,
+			patch : patch,
+			preview : preview,
+			previewNum : previewNum
+		};
+	}
+	public function testToString() {
+		assertEquals( "0.1.2", make(0,1,2) );
+
+		// Release Tags
+		assertEquals( "0.1.2-alpha", make(0,1,2,ALPHA) );
+		assertEquals( "0.1.2-beta", make(0,1,2,BETA) );
+		assertEquals( "0.1.2-rc", make(0,1,2,RC) );
+
+		// Release Tag Versions
+		assertEquals( "0.1.2-alpha.0", make(0,1,2,ALPHA,0) );
+		assertEquals( "0.1.2-beta.0", make(0,1,2,BETA,0) );
+		assertEquals( "0.1.2-rc.0", make(0,1,2,RC,0) );
+
+		// Weird input
+		assertEquals( "0.1.2", make(0,1,2,null,0) );
+
+		// Multiple characters
+		assertEquals( "100.200.300-rc.400", make(100,200,300,RC,400) );
+	}
+
+	public function testOfString() {
+		// Normal
+		assertEquals( "0.1.2", (SemVer.ofString("0.1.2").data : SemVer));
+		assertEquals( "100.50.200", (SemVer.ofString("100.50.200").data : SemVer));
+
+		// Release tags
+		assertEquals( "0.1.2-alpha", (SemVer.ofString("0.1.2-ALPHA").data : SemVer));
+		assertEquals( "0.1.2-alpha", (SemVer.ofString("0.1.2-alpha").data : SemVer));
+		assertEquals( "0.1.2-beta", (SemVer.ofString("0.1.2-beta").data : SemVer));
+		assertEquals( "0.1.2-rc", (SemVer.ofString("0.1.2-rc").data : SemVer));
+		assertEquals( "0.1.2-rc.1", (SemVer.ofString("0.1.2-rc.1").data : SemVer));
+	}
+
+	public function testOfStringInvalid() {
+		assertEquals( "invalid", parseInvalid(null) );
+		assertEquals( "invalid", parseInvalid("") );
+		assertEquals( "invalid", parseInvalid("1") );
+		assertEquals( "invalid", parseInvalid("1.1") );
+		assertEquals( "invalid", parseInvalid("1.2.a") );
+		assertEquals( "invalid", parseInvalid("a.b.c") );
+		assertEquals( "invalid", parseInvalid("1.2.3-") );
+		assertEquals( "invalid", parseInvalid("1.2.3-rc.") );
+		assertEquals( "invalid", parseInvalid("1.2.3--rc.1") );
+		assertEquals( "invalid", parseInvalid("1.2.3-othertag") );
+		assertEquals( "invalid", parseInvalid("1.2.3-othertag.1") );
+		assertEquals( "invalid", parseInvalid("10.050.02"));
+		assertEquals( "invalid", parseInvalid("10.50.2-rc.01"));
+	}
+
+	function parseInvalid( str:String ) {
+		return try {
+			(SemVer.ofString( str ) : String);
+		} catch (e:String) {
+			"invalid";
+		}
+	}
+
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/TestVcs.hx

@@ -0,0 +1,246 @@
+package tests;
+
+import sys.io.*;
+import sys.FileSystem;
+import haxe.io.*;
+import haxe.unit.TestCase;
+
+import haxelib.client.Cli;
+import haxelib.client.Vcs;
+
+class TestVcs extends TestBase
+{
+	//----------- properties, fields ------------//
+
+	static inline var REPO_ROOT = "test/libraries";
+	static inline var REPO_DIR = "vcs";
+	static var CWD:String = null;
+
+	var id:VcsID = null;
+	var vcsName:String = null;
+	var url:String = null;
+	var rev:String = null;
+	var counter:Int = 0;
+
+	//--------------- constructor ---------------//
+
+	public function new(id:VcsID, vcsName:String, url:String, ?rev:String)
+	{
+		super();
+		this.id = id;
+		this.url = url;
+		this.rev = rev;
+		this.vcsName = vcsName;
+
+		CWD = Sys.getCwd();
+		counter = 0;
+	}
+
+
+	//--------------- initialize ----------------//
+
+	override public function setup():Void
+	{
+		Sys.setCwd(Path.join([CWD, REPO_ROOT]));
+
+		if(FileSystem.exists(REPO_DIR)) {
+			deleteDirectory(REPO_DIR);
+		}
+		FileSystem.createDirectory(REPO_DIR);
+
+		Sys.setCwd(REPO_DIR);
+	}
+
+	override public function tearDown():Void
+	{
+		// restore original CWD:
+		Sys.setCwd(CWD);
+
+		deleteDirectory(Path.join([CWD, REPO_ROOT, REPO_DIR]));
+	}
+
+	//----------------- tests -------------------//
+
+
+	public function testGetVcs():Void
+	{
+		assertTrue(Vcs.get(id, {quiet: true}) != null);
+		assertTrue(Vcs.get(id, {quiet: true}).name == vcsName);
+	}
+
+	public function testAvailable():Void
+	{
+		assertTrue(getVcs().available);
+	}
+
+	// --------------- clone --------------- //
+
+	public function testGetVcsByDir():Void
+	{
+		var vcs = getVcs();
+		testCloneSimple();
+
+		assertEquals(vcs, Vcs.get(id, {quiet: true}));
+	}
+
+	public function testCloneSimple():Void
+	{
+		var vcs = getVcs();
+		var dir = vcs.directory + counter++;
+		vcs.clone(dir, url);
+
+		assertTrue(FileSystem.exists(dir));
+		assertTrue(FileSystem.isDirectory(dir));
+
+		assertTrue(FileSystem.exists('$dir/.${vcs.directory}'));
+		assertTrue(FileSystem.isDirectory('$dir/.${vcs.directory}'));
+	}
+
+	public function testCloneBranch():Void
+	{
+		var vcs = getVcs();
+		var dir = vcs.directory + counter++;
+		vcs.clone(dir, url, "develop");
+
+		assertTrue(FileSystem.exists(dir));
+		assertTrue(FileSystem.isDirectory(dir));
+
+		assertTrue(FileSystem.exists('$dir/.${vcs.directory}'));
+		assertTrue(FileSystem.isDirectory('$dir/.${vcs.directory}'));
+	}
+
+	public function testCloneBranchTag_0_9_2():Void
+	{
+		var vcs = getVcs();
+		var dir = vcs.directory + counter++;
+		vcs.clone(dir, url, "develop", "0.9.2");
+		Sys.sleep(3);
+		assertTrue(FileSystem.exists(dir));
+		assertTrue(FileSystem.exists('$dir/.${vcs.directory}'));
+
+		// if that repo "README.md" was added in tag/rev.: "0.9.3"
+		assertFalse(FileSystem.exists(dir + "/README.md"));
+	}
+
+	public function testCloneBranchTag_0_9_3():Void
+	{
+		var vcs = getVcs();
+		var dir = vcs.directory + counter++;
+		vcs.clone(dir, url, "develop", "0.9.3");
+
+		assertTrue(FileSystem.exists(dir));
+		assertTrue(FileSystem.exists('$dir/.${vcs.directory}'));
+
+		// if that repo "README.md" was added in tag/rev.: "0.9.3"
+		assertTrue(FileSystem.exists(dir + "/README.md"));
+	}
+
+	public function testCloneBranchRev():Void
+	{
+		var vcs = getVcs();
+		var dir = vcs.directory + counter++;
+		vcs.clone(dir, url, "develop", rev);
+
+		assertTrue(FileSystem.exists(dir));
+		assertTrue(FileSystem.exists('$dir/.${vcs.directory}'));
+
+		// if that repo "README.md" was added in tag/rev.: "0.9.3"
+		assertFalse(FileSystem.exists(dir + "/README.md"));
+	}
+
+
+	// --------------- update --------------- //
+
+	public function testUpdateBranchTag_0_9_2__toLatest():Void
+	{
+		var vcs = getVcs();
+		var dir = vcs.directory + counter;// increment will do in `testCloneBranchTag_0_9_2`
+
+		testCloneBranchTag_0_9_2();
+		assertFalse(FileSystem.exists("README.md"));
+
+		// save CWD:
+		var cwd = Sys.getCwd();
+		Sys.setCwd(cwd + dir);
+		assertTrue(FileSystem.exists("." + vcs.directory));
+
+		// in this case `libName` can get any value:
+		vcs.update("LIBNAME");
+
+		// Now we get actual version (0.9.3 or newer) with README.md.
+		assertTrue(FileSystem.exists("README.md"));
+
+		// restore CWD:
+		Sys.setCwd(cwd);
+	}
+
+
+	public function testUpdateBranchTag_0_9_2__toLatest__afterUserChanges_withReset():Void
+	{
+		var vcs = getVcs();
+		var dir = vcs.directory + counter;// increment will do in `testCloneBranchTag_0_9_2`
+
+		testCloneBranchTag_0_9_2();
+		assertFalse(FileSystem.exists("README.md"));
+
+		// save CWD:
+		var cwd = Sys.getCwd();
+		Sys.setCwd(cwd + dir);
+
+		// creating user-changes:
+		FileSystem.deleteFile("build.hxml");
+		File.saveContent("file", "new file \"file\" with content");
+
+		//Hack: set the default answer:
+		Cli.defaultAnswer = true;
+
+		// update to HEAD:
+		// in this case `libName` can get any value:
+		vcs.update("LIBNAME");
+
+		// Now we get actual version (0.9.3 or newer) with README.md.
+		assertTrue(FileSystem.exists("README.md"));
+
+		// restore CWD:
+		Sys.setCwd(cwd);
+	}
+
+	public function testUpdateBranchTag_0_9_2__toLatest__afterUserChanges_withoutReset():Void
+	{
+		var vcs = getVcs();
+		var dir = vcs.directory + counter;// increment will do in `testCloneBranchTag_0_9_2`
+
+		testCloneBranchTag_0_9_2();
+		assertFalse(FileSystem.exists("README.md"));
+
+		// save CWD:
+		var cwd = Sys.getCwd();
+		Sys.setCwd(cwd + dir);
+
+		// creating user-changes:
+		FileSystem.deleteFile("build.hxml");
+		File.saveContent("file", "new file \"file\" with content");
+
+		//Hack: set the default answer:
+		Cli.defaultAnswer = false;
+
+		// update to HEAD:
+		// in this case `libName` can get any value:
+		vcs.update("LIBNAME");
+
+		// We get no reset and update:
+		assertTrue(FileSystem.exists("file"));
+		assertFalse(FileSystem.exists("build.hxml"));
+		assertFalse(FileSystem.exists("README.md"));
+
+		// restore CWD:
+		Sys.setCwd(cwd);
+	}
+
+	//----------------- tools -------------------//
+
+	inline function getVcs():Vcs
+	{
+		return Vcs.get(id, {quiet: true});
+	}
+}

hGameTest/node_modules/haxe/downloads/haxelib/test/tests/TestVcsNotFound.hx

@@ -0,0 +1,183 @@
+package tests;
+
+import sys.FileSystem;
+import haxe.io.*;
+
+import haxelib.client.Vcs;
+
+class TestVcsNotFound extends TestBase
+{
+	//----------- properties, fields ------------//
+
+	static inline var REPO_ROOT = "test/libraries";
+	static inline var REPO_DIR = "vcs-no";
+	static var CWD:String = null;
+
+	//--------------- constructor ---------------//
+	public function new()
+	{
+		super();
+		CWD = Sys.getCwd();
+	}
+
+
+	//--------------- initialize ----------------//
+
+	override public function setup():Void
+	{
+		Sys.setCwd(Path.join([CWD, REPO_ROOT]));
+
+		if(FileSystem.exists(REPO_DIR)) {
+			deleteDirectory(REPO_DIR);
+		}
+		FileSystem.createDirectory(REPO_DIR);
+
+		Sys.setCwd(REPO_DIR);
+	}
+
+	override public function tearDown():Void
+	{
+		// restore original CWD & PATH:
+		Sys.setCwd(CWD);
+
+		deleteDirectory(Path.join([CWD, REPO_ROOT, REPO_DIR]));
+	}
+
+	//----------------- tests -------------------//
+
+
+	public function testAvailableHg():Void
+	{
+		assertFalse(getHg().available);
+	}
+
+	public function testAvailableGit():Void
+	{
+		assertFalse(getGit().available);
+	}
+
+
+	public function testCloneHg():Void
+	{
+		var vcs = getHg();
+		try
+		{
+			vcs.clone(vcs.directory, "https://bitbucket.org/fzzr/hx.signal");
+			assertFalse(true);
+		}
+		catch(error:VcsError)
+		{
+			switch(error)
+			{
+				case VcsError.CantCloneRepo(_, repo, stderr): assertTrue(true);
+				default: assertFalse(true);
+			}
+		}
+	}
+
+	public function testCloneGit():Void
+	{
+		var vcs = getGit();
+		try
+		{
+			vcs.clone(vcs.directory, "https://github.com/fzzr-/hx.signal.git");
+			assertFalse(true);
+		}
+		catch(error:VcsError)
+		{
+			switch(error)
+			{
+				case VcsError.CantCloneRepo(_, repo, stderr): assertTrue(true);
+				default: assertFalse(true);
+			}
+		}
+	}
+
+
+	//----------------- tools -------------------//
+
+	inline function getHg():Vcs
+	{
+		return new WrongHg({quiet: true});
+	}
+
+	inline function getGit():Vcs
+	{
+		return new WrongGit({quiet: true});
+	}
+}
+
+
+
+class WrongHg extends Mercurial
+{
+	public function new(settings:Settings)
+	{
+		super(settings);
+		this.directory = "no-hg";
+		this.executable = "no-hg";
+		this.name = "Mercurial-not-found";
+	}
+
+	// copy of Mercurial.searchExecutablebut have a one change - regexp.
+	override private function searchExecutable():Void
+	{
+		super.searchExecutable();
+
+		if(available)
+			return;
+
+		// if we have already msys git/cmd in our PATH
+		var match = ~/(.*)no-hg-no([\\|\/])cmd$/;
+		for(path in Sys.getEnv("PATH").split(";"))
+		{
+			if(match.match(path.toLowerCase()))
+			{
+				var newPath = match.matched(1) + executable + match.matched(2) + "bin";
+				Sys.putEnv("PATH", Sys.getEnv("PATH") + ";" + newPath);
+			}
+		}
+		checkExecutable();
+	}
+}
+
+class WrongGit extends Git
+{
+	public function new(settings:Settings)
+	{
+		super(settings);
+		this.directory = "no-git";
+		this.executable = "no-git";
+		this.name = "Git-not-found";
+	}
+
+	// copy of Mercurial.searchExecutablebut have a one change - regexp.
+	override private function searchExecutable():Void
+	{
+		super.searchExecutable();
+
+		if(available)
+			return;
+
+		// if we have already msys git/cmd in our PATH
+		var match = ~/(.*)no-git-no([\\|\/])cmd$/;
+		for(path in Sys.getEnv("PATH").split(";"))
+		{
+			if(match.match(path.toLowerCase()))
+			{
+				var newPath = match.matched(1) + executable + match.matched(2) + "bin";
+				Sys.putEnv("PATH", Sys.getEnv("PATH") + ";" + newPath);
+			}
+		}
+		if(checkExecutable())
+			return;
+		// look at a few default paths
+		for(path in ["C:\\Program Files (x86)\\Git\\bin", "C:\\Progra~1\\Git\\bin"])
+			if(FileSystem.exists(path))
+			{
+				Sys.putEnv("PATH", Sys.getEnv("PATH") + ";" + path);
+				if(checkExecutable())
+					return;
+			}
+	}
+}

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);
+		}
+	}
+}