int u0025_jsonwriter__test_jsonwriter(SG_context * pCtx)
{
	SG_string* pstr = NULL;

	VERIFY_ERR_CHECK_RETURN(  SG_STRING__ALLOC(pCtx, &pstr)  );

	VERIFY_ERR_CHECK_RETURN(  u0025_jsonwriter__create_1(pCtx, pstr)  );
	VERIFY_ERR_CHECK_RETURN(  u0025_jsonwriter__verify(pCtx, pstr)  );

	//printf("%s\n", SG_string__sz(pstr));

	SG_STRING_NULLFREE(pCtx, pstr);

	return 1;
}
Beispiel #2
0
int u0020_utf8pathnames__test(SG_context * pCtx)
{
	SG_pathname * pPathnameTmpDir;
	int k, kLimit;

	// create a temporary directory.

	VERIFY_ERR_CHECK_RETURN(  u0020_utf8pathnames__mkdir_tmp_dir(pCtx, &pPathnameTmpDir)  );

	INFOP("u0020_utf8pathnames",("Creating directory [%s]",SG_pathname__sz(pPathnameTmpDir)));

	// create a series of files in the temporary directory that have
	// various unicode characters in their names.

	kLimit = SG_NrElements(table);
	for (k=0; k<kLimit; k++)
	{
		_tableitem * pti = &table[k];

		INFOP("u0020_utf8pathnames",("[%d] starts with [%c]",k,pti->pa8[0]));
		VERIFY_ERR_CHECK_DISCARD(  u0020_utf8pathnames__create_file(pCtx,pPathnameTmpDir,pti)  );
	}

	// open the tmp dir for reading and read the filename of each file in it.
	// compare these with the version of the filename that we used to create
	// the file.

	VERIFY_ERR_CHECK_DISCARD(  u0020_utf8pathnames__readdir(pCtx, pPathnameTmpDir)  );

	// clean up our mess

	VERIFY_ERR_CHECK_DISCARD(  SG_fsobj__rmdir_recursive__pathname(pCtx, pPathnameTmpDir)  );

	SG_PATHNAME_NULLFREE(pCtx, pPathnameTmpDir);
	return 1;
}
Beispiel #3
0
int u0040_unc__stat_dir(SG_context * pCtx, const char * szDir)
{
	SG_pathname * pPathname = NULL;
	SG_pathname * pPathnameFile = NULL;
	SG_file * pf = NULL;
	SG_fsobj_stat fsobjStat;
	SG_bool bFileExists;
	SG_int_to_string_buffer bufSize;
	char bufDate[100];

	SG_context__err_reset(pCtx);

	//////////////////////////////////////////////////////////////////
	// stat the given directory.
	//////////////////////////////////////////////////////////////////

	INFOP("u0040_unc",("Inspecting [%s]",szDir));

	VERIFY_ERR_CHECK_RETURN(  SG_PATHNAME__ALLOC__SZ(pCtx,&pPathname,szDir)  );

	VERIFY_ERR_CHECK(  SG_fsobj__stat__pathname(pCtx,pPathname,&fsobjStat)  );
	VERIFY_COND("u0040_unc",(fsobjStat.type == SG_FSOBJ_TYPE__DIRECTORY));

	// TODO should we verify length == 0 ?
	// TODO should we verify modtime ?

	SG_uint64_to_sz(fsobjStat.size, bufSize);
	VERIFY_ERR_CHECK_DISCARD(  SG_time__format_utc__i64(pCtx,fsobjStat.mtime_ms,bufDate,SG_NrElements(bufDate))  );

	INFOP("u0040_unc",("Result: [perms %04o][type %d][size %s][mtime %s]",
					   fsobjStat.perms,fsobjStat.type,
					   bufSize,bufDate));

	//////////////////////////////////////////////////////////////////
	// create a unique file in the directory and stat it.
	//////////////////////////////////////////////////////////////////

	VERIFY_ERR_CHECK(  unittest__alloc_unique_pathname(pCtx,szDir,&pPathnameFile)  );

	INFOP("u0040_unc",("    Creating file [%s]",SG_pathname__sz(pPathnameFile)));

	VERIFY_ERR_CHECK(  SG_file__open__pathname(pCtx,pPathnameFile,SG_FILE_CREATE_NEW | SG_FILE_RDWR,0777,&pf)  );

	VERIFY_ERR_CHECK(  SG_fsobj__stat__pathname(pCtx,pPathnameFile,&fsobjStat)  );
	VERIFY_COND("u0040_unc",(fsobjStat.type == SG_FSOBJ_TYPE__REGULAR));
	VERIFY_COND("u0040_unc",(fsobjStat.size == 0));
	VERIFY_COND("u0040_unc",(SG_fsobj__equivalent_perms(fsobjStat.perms,0777)));
	// TODO should we verify modtime ?

	SG_uint64_to_sz(fsobjStat.size, bufSize);
	VERIFY_ERR_CHECK_DISCARD(  SG_time__format_utc__i64(pCtx,fsobjStat.mtime_ms,bufDate,SG_NrElements(bufDate))  );

	INFOP("u0040_unc",("    Result: [perms %04o][type %d][size %s][mtime %s]",
					   fsobjStat.perms,fsobjStat.type,
					   bufSize,bufDate));

	VERIFY_ERR_CHECK_DISCARD(  SG_file__close(pCtx, &pf)  );

	// delete the file and stat it again

	VERIFY_ERR_CHECK_DISCARD(  SG_fsobj__remove__pathname(pCtx,pPathnameFile)  );
	VERIFY_ERR_CHECK_DISCARD(  SG_fsobj__exists__pathname(pCtx,pPathnameFile,&bFileExists,NULL,NULL)  );
	VERIFY_COND("u0040_unc",(!bFileExists));

	//////////////////////////////////////////////////////////////////
	// clean up
	//////////////////////////////////////////////////////////////////

	SG_PATHNAME_NULLFREE(pCtx, pPathnameFile);
	SG_PATHNAME_NULLFREE(pCtx, pPathname);
	return 1;

fail:
	SG_FILE_NULLCLOSE(pCtx, pf);
	SG_PATHNAME_NULLFREE(pCtx, pPathnameFile);
	SG_PATHNAME_NULLFREE(pCtx, pPathname);
	return 0;
}