resconf.tsy

bind 9.3结合mysql数据库

	create_conf_file(CONF_FILENAME, 0,
			 "nameprep	invalid-version",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_name);
}

//# TESTCASE
//	title: load file (define nameprep twice)
//	group: generic-init quiet
{
#ifndef WITHOUT_ICONV
	SKIP_TESTCASE;
#else
	create_conf_file(CONF_FILENAME, CONF_NO_EOF_NEWLINE,
			 "nameprep	" IDN_NAMEPREP_CURRENT,
			 "nameprep	" IDN_NAMEPREP_CURRENT,
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_syntax);
#endif
}

//# TESTCASE
//	title: load file (invalid parameter for local-map)
//	group: generic-init quiet
{
	create_conf_file(CONF_FILENAME, 0,
			 "local-map	.jp	:",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_name);

	create_conf_file(CONF_FILENAME, 0,
			 "local-map	.jp	invalid:/dev/null",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_name);

	create_conf_file(CONF_FILENAME, 0,
			 "local-map	.jp	filemap",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_nofile);

	create_conf_file(CONF_FILENAME, 0,
			 "local-map	.jp	filemap:",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_nofile);

	create_conf_file(CONF_FILENAME, 0,
			 "local-map	.jp	filemap:no-such-file",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_nofile);

	create_conf_file(CONF_FILENAME, 0,
			 "local-map "
			 "abcdefghijklmnopqrstuvwxyz0123"
			 "abcdefghijklmnopqrstuvwxyz0123"
			 "4567 "
			 IDN_NAMEPREP_CURRENT,
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_name);
}

//# TESTCASE
//	title: load file (pass wrong number of parameters to idn-encoding)
//	group: generic-init quiet
{
	create_conf_file(CONF_FILENAME, 0,
			 "idn-encoding	",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_syntax);

	create_conf_file(CONF_FILENAME, 0,
			 "idn-encoding	Punycode ?",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_syntax);
}

//# TESTCASE
//	title: load file (pass wrong number of parameters to nameprep)
//	group: generic-init quiet
{
	create_conf_file(CONF_FILENAME, 0,
			 "nameprep	",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_syntax);

	create_conf_file(CONF_FILENAME, 0,
			 "nameprep	" IDN_NAMEPREP_CURRENT " ?",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_syntax);
}

//# TESTCASE
//	title: load file (pass wrong number of parameters to local-map)
//	group: generic-init quiet
{
	create_conf_file(CONF_FILENAME, 0,
			 "local-map	",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_syntax);

	create_conf_file(CONF_FILENAME, 0,
			 "local-map	.jp	",
			 NULL);
	r = idn_resconf_loadfile(ctx, CONF_FILENAME);
	ASSERT_RESULT(r, idn_invalid_syntax);
}

//# TESTCASE
//	title: getdelimitermap
//	group: generic-init set-defaults delimitermap_ctx
{
	delimitermap_ctx1 = idn_resconf_getdelimitermap(ctx);
	ASSERT_PTR_NE(delimitermap_ctx1, NULL);
}

//# TESTCASE
//	title: setdelimitermap
//	group: generic-init set-defaults delimitermap_ctx
{
	r = idn_delimitermap_create(&delimitermap_ctx1);
	ASSERT_RESULT(r, idn_success);

	/* set delimitermap context. */
	idn_resconf_setdelimitermap(ctx, delimitermap_ctx1);
	delimitermap_ctx2 = idn_resconf_getdelimitermap(ctx);
	ASSERT_PTR(delimitermap_ctx2, delimitermap_ctx1);
	idn_delimitermap_destroy(delimitermap_ctx2);

	/* set NULL as delimitermap context */
	idn_resconf_setdelimitermap(ctx, NULL);
	delimitermap_ctx2 = idn_resconf_getdelimitermap(ctx);
	ASSERT_PTR(delimitermap_ctx2, NULL);
}

//# TESTCASE
//	title: addalldelimitermapucs
//	group: generic-init set-defaults
{
	static unsigned long v[] = {0x002C, 0x3001, 0xFF0C};
	int nv = sizeof(v) / sizeof(*v);

	r = idn_resconf_addalldelimitermapucs(ctx, v, nv);
	ASSERT_RESULT(r, idn_success);
}

//# TESTCASE
//	title: getidnconverter
//	group: generic-init set-defaults idnconverter_ctx
{
	idnconverter_ctx1 = idn_resconf_getidnconverter(ctx);
	ASSERT_PTR_NE(idnconverter_ctx1, NULL);
}

//# TESTCASE
//	title: setidnconverter
//	group: generic-init set-defaults idnconverter_ctx
{
	r = idn_converter_create("Punycode", &idnconverter_ctx1, 0);
	ASSERT_RESULT(r, idn_success);

	/* set idnconverter context. */
	idn_resconf_setidnconverter(ctx, idnconverter_ctx1);
	idnconverter_ctx2 = idn_resconf_getidnconverter(ctx);
	ASSERT_PTR(idnconverter_ctx2, idnconverter_ctx1);
	idn_converter_destroy(idnconverter_ctx2);

	/* set NULL as idnconverter context */
	idn_resconf_setidnconverter(ctx, NULL);
	idnconverter_ctx2 = idn_resconf_getidnconverter(ctx);
	ASSERT_PTR(idnconverter_ctx2, NULL);
}

//# TESTCASE
//	title: getlocalconverter
//	group: generic-init set-defaults localconverter_ctx
{
	localconverter_ctx1 = idn_resconf_getlocalconverter(ctx);
#ifdef WITHOUT_ICONV
	ASSERT_PTR(localconverter_ctx1, NULL);
#else
	ASSERT_PTR_NE(localconverter_ctx1, NULL);
#endif
}

//# TESTCASE
//	title: setlocalconverter
//	group: generic-init set-defaults localconverter_ctx
{
	r = idn_converter_create("UTF-8", &localconverter_ctx1, 0);
	ASSERT_RESULT(r, idn_success);

	/* set localconverter context. */
	idn_resconf_setlocalconverter(ctx, localconverter_ctx1);
	localconverter_ctx2 = idn_resconf_getlocalconverter(ctx);
#ifdef WITHOUT_ICONV
	ASSERT_PTR(localconverter_ctx2, NULL);
#else
	ASSERT_PTR(localconverter_ctx2, localconverter_ctx1);
	idn_converter_destroy(localconverter_ctx2);
#endif

	/* set NULL as localconverter context */
	idn_resconf_setlocalconverter(ctx, NULL);
	localconverter_ctx2 = idn_resconf_getlocalconverter(ctx);
#ifdef WITHOUT_ICONV
	ASSERT_PTR(localconverter_ctx2, NULL);
#else
	ASSERT_PTR_NE(localconverter_ctx2, NULL);
#endif
}

//# TESTCASE
//	title: getauxidnconverter
//	group: generic-init set-defaults auxidnconverter_ctx
{
	auxidnconverter_ctx1 = idn_resconf_getauxidnconverter(ctx);
	ASSERT_PTR(auxidnconverter_ctx1, NULL);
}

//# TESTCASE
//	title: setauxidnconverter
//	group: generic-init set-defaults auxidnconverter_ctx
{
	r = idn_converter_create("Punycode", &auxidnconverter_ctx1, 0);
	ASSERT_RESULT(r, idn_success);

	/* set auxidnconverter context. */
	idn_resconf_setauxidnconverter(ctx, auxidnconverter_ctx1);
	auxidnconverter_ctx2 = idn_resconf_getauxidnconverter(ctx);
	ASSERT_PTR(auxidnconverter_ctx2, auxidnconverter_ctx1);
	idn_converter_destroy(auxidnconverter_ctx2);

	/* set NULL as auxidnconverter context */
	idn_resconf_setauxidnconverter(ctx, NULL);
	auxidnconverter_ctx2 = idn_resconf_getauxidnconverter(ctx);
	ASSERT_PTR(auxidnconverter_ctx2, NULL);
}

//# TESTCASE
//	title: getlocalmapselector
//	group: generic-init set-defaults mapselector_ctx
{
	mapselector_ctx1 = idn_resconf_getlocalmapselector(ctx);
	ASSERT_PTR(mapselector_ctx1, NULL);
}

//# TESTCASE
//	title: setlocalmapselector
//	group: generic-init set-defaults mapselector_ctx
{
	r = idn_mapselector_create(&mapselector_ctx1);
	ASSERT_RESULT(r, idn_success);

	/* set localmapselector context. */
	idn_resconf_setlocalmapselector(ctx, mapselector_ctx1);
	mapselector_ctx2 = idn_resconf_getlocalmapselector(ctx);
	ASSERT_PTR(mapselector_ctx2, mapselector_ctx1);
	idn_mapselector_destroy(mapselector_ctx2);

	/* set NULL as localmapselector context */
	idn_resconf_setlocalmapselector(ctx, NULL);
	mapselector_ctx2 = idn_resconf_getlocalmapselector(ctx);
	ASSERT_PTR(mapselector_ctx2, NULL);
}

//# TESTCASE
//	title: addalllocalmapselectornames
//	group: generic-init set-defaults
{
	static const char *names[] = {
		"filemap:" MAP_FILENAME,
		"filemap:" MAP_FILENAME,
		"filemap:" MAP_FILENAME
	};
	int nnames = sizeof(names) / sizeof(*names);

	create_conf_file(MAP_FILENAME, 0,
			 "2212; FF0D",
			 NULL);
	r = idn_resconf_addalllocalmapselectornames(ctx, ".jp", names, nnames);
	ASSERT_RESULT(r, idn_success);
}

//# TESTCASE
//	title: getmapper
//	group: generic-init set-defaults mapper_ctx
{
	mapper_ctx1 = idn_resconf_getmapper(ctx);
	ASSERT_PTR_NE(mapper_ctx1, NULL);
}

//# TESTCASE
//	title: setmapper
//	group: generic-init set-defaults mapper_ctx
{
	r = idn_mapper_create(&mapper_ctx1);
	ASSERT_RESULT(r, idn_success);

	/* set mapper context. */
	idn_resconf_setmapper(ctx, mapper_ctx1);
	mapper_ctx2 = idn_resconf_getmapper(ctx);
	ASSERT_PTR(mapper_ctx2, mapper_ctx1);
	idn_mapper_destroy(mapper_ctx2);

	/* set NULL as mapper context */
	idn_resconf_setmapper(ctx, NULL);
	mapper_ctx2 = idn_resconf_getmapper(ctx);
	ASSERT_PTR(mapper_ctx2, NULL);
}

//# TESTCASE
//	title: addallmappernames
//	group: generic-init set-defaults
{
	static const char *names[] = {
		IDN_NAMEPREP_CURRENT,
		IDN_NAMEPREP_CURRENT,
		IDN_NAMEPREP_CURRENT
	};
	int nnames = sizeof(names) / sizeof(*names);

	r = idn_resconf_addallmappernames(ctx, names, nnames);
	ASSERT_RESULT(r, idn_success);
}

//# TESTCASE
//	title: getnormalizer
//	group: generic-init set-defaults normalizer_ctx
{
	normalizer_ctx1 = idn_resconf_getnormalizer(ctx);
	ASSERT_PTR_NE(normalizer_ctx1, NULL);
}

//# TESTCASE
//	title: setnormalizer
//	group: generic-init set-defaults normalizer_ctx
{
	r = idn_normalizer_create(&normalizer_ctx1);
	ASSERT_RESULT(r, idn_success);

	/* set normalizer context. */
	idn_resconf_setnormalizer(ctx, normalizer_ctx1);
	normalizer_ctx2 = idn_resconf_getnormalizer(ctx);
	ASSERT_PTR(normalizer_ctx2, normalizer_ctx1);
	idn_normalizer_destroy(normalizer_ctx2);

	/* set NULL as normalizer context */
	idn_resconf_setnormalizer(ctx, NULL);
	normalizer_ctx2 = idn_resconf_getnormalizer(ctx);
	ASSERT_PTR(normalizer_ctx2, NULL);
}

//# TESTCASE
//	title: addallnormalizernames
//	group: generic-init set-defaults
{
	static const char *names[] = {
		IDN_NAMEPREP_CURRENT,
		IDN_NAMEPREP_CURRENT,
		IDN_NAMEPREP_CURRENT
	};
	int nnames = sizeof(names) / sizeof(*names);

	r = idn_resconf_addallnormalizernames(ctx, names, nnames);
	ASSERT_RESULT(r, idn_success);
}

//# TESTCASE
//	title: getprohibitchecker
//	group: generic-init set-defaults prohibitchecker_ctx
{
	prohibitchecker_ctx1 = idn_resconf_getprohibitchecker(ctx);
	ASSERT_PTR_NE(prohibitchecker_ctx1, NULL);
}

//# TESTCASE
//	title: setprohibitchecker
//	group: generic-init set-defaults prohibitchecker_ctx
{
	r = idn_checker_create(&prohibitchecker_ctx1);
	ASSERT_RESULT(r, idn_success);

	/* set checker context. */
	idn_resconf_setprohibitchecker(ctx, prohibitchecker_ctx1);
	prohibitchecker_ctx2 = idn_resconf_getprohibitchecker(ctx);
	ASSERT_PTR(prohibitchecker_ctx2, prohibitchecker_ctx1);
	idn_checker_destroy(prohibitchecker_ctx2);

	/* set NULL as checker context */
	idn_resconf_setprohibitchecker(ctx, NULL);
	prohibitchecker_ctx2 = idn_resconf_getprohibitchecker(ctx);
	ASSERT_PTR(prohibitchecker_ctx2, NULL);
}

//# TESTCASE
//	title: addallprohibitcheckernames
//	group: generic-init set-defaults
{
	static const char *names[] = {
		IDN_NAMEPREP_CURRENT,
		IDN_NAMEPREP_CURRENT,
		IDN_NAMEPREP_CURRENT
	};
	int nnames = sizeof(names) / sizeof(*names);

	r = idn_resconf_addallprohibitcheckernames(ctx, names, nnames);
	ASSERT_RESULT(r, idn_success);
}

//# TESTCASE
//	title: getunassignedchecker
//	group: generic-init set-defaults unassignedchecker_ctx
{
	unassignedchecker_ctx1 = idn_resconf_getunassignedchecker(ctx);
	ASSERT_PTR_NE(unassignedchecker_ctx1, NULL);
}

//# TESTCASE
//	title: setunassignedchecker
//	group: generic-init set-defaults unassignedchecker_ctx
{
	r = idn_checker_create(&unassignedchecker_ctx1);
	ASSERT_RESULT(r, idn_success);

	/* set checker context. */
	idn_resconf_setunassignedchecker(ctx, unassignedchecker_ctx1);
	unassignedchecker_ctx2 = idn_resconf_getunassignedchecker(ctx);
	ASSERT_PTR(unassignedchecker_ctx2, unassignedchecker_ctx1);
	idn_checker_destroy(unassignedchecker_ctx2);

	/* set NULL as checker context */
	idn_resconf_setunassignedchecker(ctx, NULL);
	unassignedchecker_ctx2 = idn_resconf_getunassignedchecker(ctx);
	ASSERT_PTR(unassignedchecker_ctx2, NULL);
}

//# TESTCASE
//	title: addallunassignedcheckernames
//	group: generic-init set-defaults
{
	static const char *names[] = {
		IDN_NAMEPREP_CURRENT,
		IDN_NAMEPREP_CURRENT,
		IDN_NAMEPREP_CURRENT
	};
	int nnames = sizeof(names) / sizeof(*names);

	r = idn_resconf_addallunassignedcheckernames(ctx, names, nnames);
	ASSERT_RESULT(r, idn_success);
}

//# TESTCASE
//	title: getbidichecker
//	group: generic-init set-defaults bidichecker_ctx
{
	bidichecker_ctx1 = idn_resconf_getbidichecker(ctx);
	ASSERT_PTR_NE(bidichecker_ctx1, NULL);
}

//# TESTCASE
//	title: setbidichecker
//	group: generic-init set-defaults bidichecker_ctx
{
	r = idn_checker_create(&bidichecker_ctx1);
	ASSERT_RESULT(r, idn_success);

	/* set checker context. */
	idn_resconf_setbidichecker(ctx, bidichecker_ctx1);
	bidichecker_ctx2 = idn_resconf_getbidichecker(ctx);
	ASSERT_PTR(bidichecker_ctx2, bidichecker_ctx1);
	idn_checker_destroy(bidichecker_ctx2);

	/* set NULL as checker context */
	idn_resconf_setbidichecker(ctx, NULL);
	bidichecker_ctx2 = idn_resconf_getbidichecker(ctx);
	ASSERT_PTR(bidichecker_ctx2, NULL);
}

//# TESTCASE
//	title: addallbidicheckernames
//	group: generic-init set-defaults
{
	static const char *names[] = {
		IDN_NAMEPREP_CURRENT,
		IDN_NAMEPREP_CURRENT,
		IDN_NAMEPREP_CURRENT
	};
	int nnames = sizeof(names) / sizeof(*names);

	r = idn_resconf_addallbidicheckernames(ctx, names, nnames);
	ASSERT_RESULT(r, idn_success);
}

//# TESTCASE
//	title: setnameprepversion
//	group: generic-init set-defaults
{
	idn_resconf_setnameprepversion(ctx, IDN_NAMEPREP_CURRENT);
	ASSERT_RESULT(r, idn_success);
}