int main(int /*argc*/, char * /*argv*/[])
{
#ifdef CUBEB_GECKO_BUILD
ScopedXPCOM xpcom("test_duplex");
#endif
cubeb *ctx;
cubeb_stream *stream;
cubeb_stream_params input_params;
cubeb_stream_params output_params;
int r;
user_state stream_state = { false };
uint32_t latency_frames = 0;
r = cubeb_init(&ctx, "Cubeb duplex example");
if (r != CUBEB_OK) {
fprintf(stderr, "Error initializing cubeb library\n");
return r;
}
/* This test needs an available input device, skip it if this host does not
* have one. */
if (!has_available_input_device(ctx)) {
return 0;
}
/* typical user-case: mono input, stereo output, low latency. */
input_params.format = STREAM_FORMAT;
input_params.rate = 48000;
input_params.channels = 1;
output_params.format = STREAM_FORMAT;
output_params.rate = 48000;
output_params.channels = 2;
r = cubeb_get_min_latency(ctx, output_params, &latency_frames);
if (r != CUBEB_OK) {
fprintf(stderr, "Could not get minimal latency\n");
return r;
}
r = cubeb_stream_init(ctx, &stream, "Cubeb duplex",
NULL, &input_params, NULL, &output_params,
latency_frames, data_cb, state_cb, &stream_state);
if (r != CUBEB_OK) {
fprintf(stderr, "Error initializing cubeb stream\n");
return r;
}
cubeb_stream_start(stream);
delay(500);
cubeb_stream_stop(stream);
cubeb_stream_destroy(stream);
cubeb_destroy(ctx);
assert(stream_state.seen_noise);
return CUBEB_OK;
}
int main(int argc, char** argv)
{
if (argc < 2)
{
fprintf(stderr, "not enough arguments -- need registration dir path\n");
return 1;
}
ScopedLogging logging;
const char *regPath = argv[1];
XRE_AddManifestLocation(NS_COMPONENT_LOCATION,
nsCOMPtr<nsILocalFile>(GetRegDirectory(regPath, "core", "component.manifest")));
XRE_AddManifestLocation(NS_COMPONENT_LOCATION,
nsCOMPtr<nsILocalFile>(GetRegDirectory(regPath, "extension", "extComponent.manifest")));
XRE_AddJarManifestLocation(NS_COMPONENT_LOCATION,
nsCOMPtr<nsILocalFile>(GetRegDirectory(regPath, "extension2.jar", NULL)));
ScopedXPCOM xpcom("RegistrationOrder");
if (xpcom.failed())
return 1;
int rv = 0;
if (NS_FAILED(TestRegular()))
rv = 1;
if (NS_FAILED(TestJar()))
rv = 1;
if (!TestContractFirst())
rv = 1;
return rv;
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("Base64");
NS_ENSURE_FALSE(xpcom.failed(), 1);
nsCOMPtr<nsIScriptableBase64Encoder> encoder =
do_CreateInstance("@mozilla.org/scriptablebase64encoder;1");
NS_ENSURE_TRUE(encoder, 1);
nsRefPtr<FakeInputStream> stream = new FakeInputStream();
do {
nsString wideString;
nsCString string;
nsresult rv;
rv = encoder->EncodeToString(stream, 0, wideString);
NS_ENSURE_SUCCESS(rv, 1);
stream->Reset();
rv = encoder->EncodeToCString(stream, 0, string);
NS_ENSURE_SUCCESS(rv, 1);
if (!stream->CheckTest(wideString) || !stream->CheckTest(string))
fail("Failed to convert properly\n");
} while (stream->NextTest());
return 0;
}
int main(int argc, char **argv)
{
ScopedXPCOM xpcom("TestMimeCrash");
if (xpcom.failed())
return 1;
// We cannot use malloc() since this crashes depends on memory allocation.
// By using mmap()/PR_MemMap(), end of buffer that is last in the page
// sets LF.
PRUint32 bufsize = PR_GetPageSize();
PRFileMap *fm = PR_OpenAnonFileMap(".", bufsize, PR_PROT_READWRITE);
if (!fm)
return 1;
char *addr = (char *) PR_MemMap(fm, 0, bufsize);
if (!addr)
return 1;
memset(addr, '\r', bufsize);
nsresult rv = do_test(addr, bufsize);
PR_MemUnmap(addr, bufsize);
PR_CloseFileMap(fm);
if (NS_FAILED(rv)) {
fail("cannot use nsIMimeConverter error=%08x\n", rv);
return -1;
}
passed("no crash");
return 0;
}
int main(int argc, char** argv) {
ScopedXPCOM xpcom("ContentSecurityPolicyParser");
if (xpcom.failed()) {
return 1;
}
if (NS_FAILED(TestDirectives())) { return 1; }
if (NS_FAILED(TestKeywords())) { return 1; }
if (NS_FAILED(TestIgnoreUpperLowerCasePolicies())) { return 1; }
if (NS_FAILED(TestIgnorePaths())) { return 1; }
if (NS_FAILED(TestSimplePolicies())) { return 1; }
if (NS_FAILED(TestPoliciesWithInvalidSrc())) { return 1; }
if (NS_FAILED(TestBadPolicies())) { return 1; }
if (NS_FAILED(TestGoodGeneratedPolicies())) { return 1; }
if (NS_FAILED(TestBadGeneratedPolicies())) { return 1; }
if (NS_FAILED(TestGoodGeneratedPoliciesForPathHandling())) { return 1; }
if (NS_FAILED(TestBadGeneratedPoliciesForPathHandling())) { return 1; }
if (NS_FAILED(TestShorteningPolicies())) { return 1; }
#if RUN_OFFLINE_TESTS
if (NS_FAILED(TestFuzzyPolicies())) { return 1; }
if (NS_FAILED(TestFuzzyPoliciesIncDir())) { return 1; }
if (NS_FAILED(TestFuzzyPoliciesIncDirLimASCII())) { return 1; }
#endif
return 0;
}
int main(int argc, char** argv) {
ScopedXPCOM xpcom("TestRegion");
if (xpcom.failed())
return -1;
if (!TestLargestRegion::Test())
return -1;
return 0;
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("");
if (xpcom.failed())
return 1;
DoAttrValueTest();
return 0;
}
int main (void) {
ScopedXPCOM xpcom("TestDeque");
NS_ENSURE_FALSE(xpcom.failed(), 1);
_TestDeque test;
int result = test.Test();
TEST(result == 0, "All tests pass");
return 0;
}
int
main(int argc, char** argv)
{
// Prevents some log spew
ScopedXPCOM xpcom("jsep_track_unittest");
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("ThreadUtils");
NS_ENSURE_FALSE(xpcom.failed(), 1);
memset(gRunnableExecuted, false, MAX_TESTS * sizeof(bool));
// Scope the smart ptrs so that the runnables need to hold on to whatever they need
{
nsRefPtr<nsFoo> foo = new nsFoo();
nsRefPtr<nsBar> bar = new nsBar();
// This pointer will be freed at the end of the block
// Do not dereference this pointer in the runnable method!
nsFoo * rawFoo = new nsFoo();
// Read only string. Dereferencing in runnable method to check this works.
char* message = (char*)"Test message";
NS_DispatchToMainThread(NS_NewRunnableMethod(bar, &nsBar::DoBar1));
NS_DispatchToMainThread(NS_NewRunnableMethod(bar, &nsBar::DoBar2));
NS_DispatchToMainThread(NS_NewRunnableMethodWithArg< nsRefPtr<nsFoo> >
(bar, &nsBar::DoBar3, foo));
NS_DispatchToMainThread(NS_NewRunnableMethodWithArg< nsRefPtr<nsFoo> >
(bar, &nsBar::DoBar4, foo));
NS_DispatchToMainThread(NS_NewRunnableMethodWithArg<nsFoo*>(bar, &nsBar::DoBar5, rawFoo));
NS_DispatchToMainThread(NS_NewRunnableMethodWithArg<char*>(bar, &nsBar::DoBar6, message));
#ifdef HAVE_STDCALL
NS_DispatchToMainThread(NS_NewRunnableMethod(bar, &nsBar::DoBar1std));
NS_DispatchToMainThread(NS_NewRunnableMethod(bar, &nsBar::DoBar2std));
NS_DispatchToMainThread(NS_NewRunnableMethodWithArg< nsRefPtr<nsFoo> >
(bar, &nsBar::DoBar3std, foo));
NS_DispatchToMainThread(NS_NewRunnableMethodWithArg< nsRefPtr<nsFoo> >
(bar, &nsBar::DoBar4std, foo));
NS_DispatchToMainThread(NS_NewRunnableMethodWithArg<nsFoo*>(bar, &nsBar::DoBar5std, rawFoo));
NS_DispatchToMainThread(NS_NewRunnableMethodWithArg<char*>(bar, &nsBar::DoBar6std, message));
#endif
delete rawFoo;
}
// Spin the event loop
NS_ProcessPendingEvents(nullptr);
int result = 0;
for (uint32_t i = 0; i < MAX_TESTS; i++) {
if (gRunnableExecuted[i]) {
passed("Test %d passed",i);
} else {
fail("Error in test %d", i);
result = 1;
}
}
return result;
}
int main(int argc, char** argv)
{
int rv = 0;
ScopedXPCOM xpcom("jemalloc");
if (xpcom.failed())
return 1;
if (NS_FAILED(TestJemallocUsableSizeInAdvance()))
rv = 1;
return rv;
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("PlainTextSerializer");
if (xpcom.failed())
return 1;
int retval = 0;
if (NS_FAILED(TestPlainTextSerializer())) {
retval = 1;
}
return retval;
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("XMLHttpRequest");
if (xpcom.failed())
return 1;
int retval = 0;
if (NS_FAILED(TestNativeXMLHttpRequest())) {
retval = 1;
}
return retval;
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("WinFileAttributes");
if (xpcom.failed())
return 1;
int rv = 0;
if(NS_FAILED(TestWinAttribs()))
rv = 1;
return rv;
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("NTFSPermissionsTests"); // name for tests being run
if (xpcom.failed())
return 1;
int rv = 0;
if(NS_FAILED(TestPermissions()))
rv = 1;
return rv;
}
int main(int argc, char * argv[])
{
#ifdef CUBEB_GECKO_BUILD
ScopedXPCOM xpcom("test_latency");
#endif
cubeb * ctx = NULL;
int r;
uint32_t max_channels;
uint32_t preferred_rate;
uint32_t latency_ms;
LOG("latency_test start");
r = cubeb_init(&ctx, "Cubeb audio test");
assert(r == CUBEB_OK && "Cubeb init failed.");
LOG("cubeb_init ok");
r = cubeb_get_max_channel_count(ctx, &max_channels);
assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED);
if (r == CUBEB_OK) {
assert(max_channels > 0 && "Invalid max channel count.");
LOG("cubeb_get_max_channel_count ok");
}
r = cubeb_get_preferred_sample_rate(ctx, &preferred_rate);
assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED);
if (r == CUBEB_OK) {
assert(preferred_rate > 0 && "Invalid preferred sample rate.");
LOG("cubeb_get_preferred_sample_rate ok");
}
cubeb_stream_params params = {
CUBEB_SAMPLE_FLOAT32NE,
preferred_rate,
max_channels
};
r = cubeb_get_min_latency(ctx, params, &latency_ms);
assert(r == CUBEB_OK || r == CUBEB_ERROR_NOT_SUPPORTED);
if (r == CUBEB_OK) {
assert(latency_ms > 0 && "Invalid minimal latency.");
LOG("cubeb_get_min_latency ok");
}
cubeb_destroy(ctx);
LOG("cubeb_destroy ok");
return EXIT_SUCCESS;
}
int
main(int argc, char * argv[])
{
#ifdef CUBEB_GECKO_BUILD
ScopedXPCOM xpcom("test_sanity");
#endif
test_init_destroy_context();
test_init_destroy_multiple_contexts();
test_context_variables();
test_init_destroy_stream();
test_init_destroy_multiple_streams();
test_configure_stream();
test_basic_stream_operations();
test_stream_position();
/* Sometimes, when using WASAPI on windows 7 (vista and 8 are okay), and
* calling Activate a lot on an AudioClient, 0x800700b7 is returned. This is
* the HRESULT value for "Cannot create a file when that file already exists",
* and is not documented as a possible return value for this call. Hence, we
* try to limit the number of streams we create in this test. */
if (!is_windows_7()) {
test_init_destroy_multiple_contexts_and_streams();
delay_callback = 0;
test_init_start_stop_destroy_multiple_streams(0, 0);
test_init_start_stop_destroy_multiple_streams(1, 0);
test_init_start_stop_destroy_multiple_streams(0, 150);
test_init_start_stop_destroy_multiple_streams(1, 150);
delay_callback = 1;
test_init_start_stop_destroy_multiple_streams(0, 0);
test_init_start_stop_destroy_multiple_streams(1, 0);
test_init_start_stop_destroy_multiple_streams(0, 150);
test_init_start_stop_destroy_multiple_streams(1, 150);
}
delay_callback = 0;
test_drain();
/*
to implement:
test_eos_during_prefill();
test_stream_destroy_pending_drain();
*/
printf("\n");
return 0;
}
int
main(int argc, char** argv)
{
ScopedXPCOM xpcom("Deadlock detector scalability (" __FILE__ ")");
if (xpcom.failed())
return 1;
int rv = 0;
// Uncomment these tests to run them. Not expected to be common.
#ifndef DD_TEST1
puts("Skipping not-requested LengthNDepChain() test");
#else
if (NS_FAILED(LengthNDepChain(1 << 14))) // 16K
rv = 1;
#endif
#ifndef DD_TEST2
puts("Skipping not-requested OneLockNDeps() test");
#else
// NB: Using a larger test size to stress our traversal logic.
if (NS_FAILED(OneLockNDeps(1 << 17, 100))) // 131k
rv = 1;
#endif
#ifndef DD_TEST3
puts("Skipping not-requested MaxDepsNsq() test");
#else
if (NS_FAILED(MaxDepsNsq(1 << 10, 10))) // 1k
rv = 1;
#endif
#ifndef DD_TEST4
puts("Skipping not-requested OneLockNDepsUsedSeveralTimes() test");
#else
if (NS_FAILED(OneLockNDepsUsedSeveralTimes(1 << 17, 3))) // 131k
rv = 1;
#endif
size_t memory_used = mozilla::BlockingResourceBase::SizeOfDeadlockDetector(
DeadlockDetectorMallocSizeOf);
printf_stderr("Used %d bytes\n", (int)memory_used);
return rv;
}
int main(int argc, char *argv[])
{
#ifdef CUBEB_GECKO_BUILD
ScopedXPCOM xpcom("test_record");
#endif
cubeb *ctx;
cubeb_stream *stream;
cubeb_stream_params params;
int r;
user_state stream_state = { false };
r = cubeb_init(&ctx, "Cubeb record example");
if (r != CUBEB_OK) {
fprintf(stderr, "Error initializing cubeb library\n");
return r;
}
/* This test needs an available input device, skip it if this host does not
* have one. */
if (!has_available_input_device(ctx)) {
return 0;
}
params.format = STREAM_FORMAT;
params.rate = SAMPLE_FREQUENCY;
params.channels = 1;
r = cubeb_stream_init(ctx, &stream, "Cubeb record (mono)", NULL, ¶ms, NULL, nullptr,
250, data_cb, state_cb, &stream_state);
if (r != CUBEB_OK) {
fprintf(stderr, "Error initializing cubeb stream\n");
return r;
}
cubeb_stream_start(stream);
delay(500);
cubeb_stream_stop(stream);
cubeb_stream_destroy(stream);
cubeb_destroy(ctx);
assert(stream_state.seen_noise);
return CUBEB_OK;
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("Test Windows Drag and Drop");
nsCOMPtr<nsIFile> file;
file = xpcom.GetProfileDirectory();
xferFile = file;
if (NS_SUCCEEDED(Do_Test1()))
passed("Basic Drag and Drop data type tests (single transferable) succeeded!");
if (NS_SUCCEEDED(Do_Test2()))
passed("Basic Drag and Drop data type tests (multiple transferables) succeeded!");
//if (NS_SUCCEEDED(Do_Test3()))
// passed("Advanced Drag and Drop data type tests succeeded!");
return gFailCount;
}
int main(int argc, char** argv)
{
if (argc < 2) {
printf("Usage: TestGetURL <url>\n");
exit(0);
}
ScopedXPCOM xpcom("XMLHttpRequest");
if (xpcom.failed())
return 1;
nsAutoCString targetURL(argv[1]);
int retval = 0;
if (NS_FAILED(TestGetURL(targetURL))) {
retval = 1;
}
return retval;
}
int main(int argc, char **argv)
{
ScopedXPCOM xpcom("URLClassiferUtils");
TestUnescape();
TestEnc();
TestCanonicalize();
TestCanonicalNum();
TestParseIPAddress();
TestHostname();
TestLongHostname();
TestFragmentSet();
if (gPassedTests == gTotalTests)
passed(__FILE__);
printf("%d of %d tests passed\n", gPassedTests, gTotalTests);
// Non-zero return status signals test failure to build system.
return (gPassedTests != gTotalTests);
}
int LibFuzzerRunner::Run(int* argc, char*** argv) {
ScopedXPCOM xpcom("LibFuzzer");
std::string moduleNameStr(getenv("LIBFUZZER"));
LibFuzzerFunctions funcs = LibFuzzerRegistry::getInstance().getModuleFunctions(moduleNameStr);
LibFuzzerInitFunc initFunc = funcs.first;
LibFuzzerTestingFunc testingFunc = funcs.second;
if (initFunc) {
int ret = initFunc(argc, argv);
if (ret) {
fprintf(stderr, "LibFuzzer: Error: Initialize callback failed\n");
return ret;
}
}
if (!testingFunc) {
fprintf(stderr, "LibFuzzer: Error: No testing callback found\n");
return 1;
}
return mFuzzerDriver(argc, argv, testingFunc);
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("nsLocalFile");
if (xpcom.failed())
return 1;
nsCOMPtr<nsIFile> base;
nsresult rv = NS_GetSpecialDirectory(NS_OS_TEMP_DIR, getter_AddRefs(base));
if (!VerifyResult(rv, "Getting temp directory"))
return 1;
rv = base->AppendNative(nsDependentCString("mozfiletests"));
if (!VerifyResult(rv, "Appending mozfiletests to temp directory name"))
return 1;
// Remove the directory in case tests failed and left it behind.
// don't check result since it might not be there
base->Remove(true);
// Now create the working directory we're going to use
rv = base->Create(nsIFile::DIRECTORY_TYPE, 0700);
if (!VerifyResult(rv, "Creating temp directory"))
return 1;
// Now we can safely normalize the path
rv = base->Normalize();
if (!VerifyResult(rv, "Normalizing temp directory name"))
return 1;
// Initialize subdir object for later use
nsCOMPtr<nsIFile> subdir = NewFile(base);
if (!subdir)
return 1;
rv = subdir->AppendNative(nsDependentCString("subdir"));
if (!VerifyResult(rv, "Appending 'subdir' to test dir name"))
return 1;
passed("Setup");
// Test path parsing
if (TestInvalidFileName(base, "a/b")) {
passed("AppendNative with invalid file name");
}
if (TestParent(base, subdir)) {
passed("GetParent");
}
// Test file creation
if (TestCreate(base, "file.txt", nsIFile::NORMAL_FILE_TYPE, 0600)) {
passed("Create file");
}
if (TestRemove(base, "file.txt", false)) {
passed("Remove file");
}
// Test directory creation
if (TestCreate(base, "subdir", nsIFile::DIRECTORY_TYPE, 0700)) {
passed("Create directory");
}
// Test move and copy in the base directory
if (TestCreate(base, "file.txt", nsIFile::NORMAL_FILE_TYPE, 0600) &&
TestMove(base, base, "file.txt", "file2.txt")) {
passed("MoveTo rename file");
}
if (TestCopy(base, base, "file2.txt", "file3.txt")) {
passed("CopyTo copy file");
}
// Test moving across directories
if (TestMove(base, subdir, "file2.txt", "file2.txt")) {
passed("MoveTo move file");
}
// Test moving across directories and renaming at the same time
if (TestMove(subdir, base, "file2.txt", "file4.txt")) {
passed("MoveTo move and rename file");
}
// Test copying across directoreis
if (TestCopy(base, subdir, "file4.txt", "file5.txt")) {
passed("CopyTo copy file across directories");
}
// Run normalization tests while the directory exists
if (TestNormalizeNativePath(base, subdir)) {
passed("Normalize with native paths");
}
// Test recursive directory removal
if (TestRemove(base, "subdir", true)) {
passed("Remove directory");
}
if (TestCreateUnique(base, "foo", nsIFile::NORMAL_FILE_TYPE, 0600) &&
TestCreateUnique(base, "foo", nsIFile::NORMAL_FILE_TYPE, 0600)) {
passed("CreateUnique file");
}
if (TestCreateUnique(base, "bar.xx", nsIFile::DIRECTORY_TYPE, 0700) &&
TestCreateUnique(base, "bar.xx", nsIFile::DIRECTORY_TYPE, 0700)) {
passed("CreateUnique directory");
}
if (TestDeleteOnClose(base, "file7.txt", PR_RDWR | PR_CREATE_FILE, 0600)) {
passed("OpenNSPRFileDesc DELETE_ON_CLOSE");
}
gFunction = "main";
// Clean up temporary stuff
rv = base->Remove(true);
VerifyResult(rv, "Cleaning up temp directory");
return gFailCount > 0;
}
int
main(int32_t argc, char *argv[])
{
nsresult rv;
ScopedXPCOM xpcom("STS Parser Tests");
if (xpcom.failed())
return -1;
// Initialize a profile folder to ensure a clean shutdown.
nsCOMPtr<nsIFile> profile = xpcom.GetProfileDirectory();
if (!profile) {
fail("Couldn't get the profile directory.");
return -1;
}
// grab handle to the service
nsCOMPtr<nsISiteSecurityService> sss;
sss = do_GetService("@mozilla.org/ssservice;1", &rv);
NS_ENSURE_SUCCESS(rv, -1);
int rv0, rv1;
nsTArray<bool> rvs(24);
// *** parsing tests
printf("*** Attempting to parse valid STS headers ...\n");
// SHOULD SUCCEED:
rvs.AppendElement(TestSuccess("max-age=100", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age =100", false, 100, false, sss));
rvs.AppendElement(TestSuccess(" max-age=100", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age = 100 ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age = \"100\" ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age=\"100\"", false, 100, false, sss));
rvs.AppendElement(TestSuccess(" max-age =\"100\" ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("\tmax-age\t=\t\"100\"\t", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age = 100 ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("maX-aGe=100", false, 100, false, sss));
rvs.AppendElement(TestSuccess("MAX-age =100", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-AGE=100", false, 100, false, sss));
rvs.AppendElement(TestSuccess("Max-Age = 100 ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("MAX-AGE = 100 ", false, 100, false, sss));
rvs.AppendElement(TestSuccess("max-age=100;includeSubdomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess("max-age=100\t; includeSubdomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess(" max-age=100; includeSubdomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess("max-age = 100 ; includeSubdomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess("max-age = 100 ; includeSubdomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess("maX-aGe=100; includeSUBDOMAINS", false, 100, true, sss));
rvs.AppendElement(TestSuccess("MAX-age =100; includeSubDomains", false, 100, true, sss));
rvs.AppendElement(TestSuccess("max-AGE=100; iNcLuDeSuBdoMaInS", false, 100, true, sss));
rvs.AppendElement(TestSuccess("Max-Age = 100; includesubdomains ", false, 100, true, sss));
rvs.AppendElement(TestSuccess("INCLUDESUBDOMAINS;MaX-AgE = 100 ", false, 100, true, sss));
// Turns out, the actual directive is entirely optional (hence the
// trailing semicolon)
rvs.AppendElement(TestSuccess("max-age=100;includeSubdomains;", true, 100, true, sss));
// these are weird tests, but are testing that some extended syntax is
// still allowed (but it is ignored)
rvs.AppendElement(TestSuccess("max-age=100 ; includesubdomainsSomeStuff", true, 100, false, sss));
rvs.AppendElement(TestSuccess("\r\n\t\t \tcompletelyUnrelated = foobar; max-age= 34520103 \t \t; alsoUnrelated;asIsThis;\tincludeSubdomains\t\t \t", true, 34520103, true, sss));
rvs.AppendElement(TestSuccess("max-age=100; unrelated=\"quoted \\\"thingy\\\"\"", true, 100, false, sss));
rv0 = rvs.Contains(false) ? 1 : 0;
if (rv0 == 0)
passed("Successfully Parsed STS headers with mixed case and LWS");
rvs.Clear();
// SHOULD FAIL:
printf("*** Attempting to parse invalid STS headers (should not parse)...\n");
// invalid max-ages
rvs.AppendElement(TestFailure("max-age", sss));
rvs.AppendElement(TestFailure("max-age ", sss));
rvs.AppendElement(TestFailure("max-age=p", sss));
rvs.AppendElement(TestFailure("max-age=*1p2", sss));
rvs.AppendElement(TestFailure("max-age=.20032", sss));
rvs.AppendElement(TestFailure("max-age=!20032", sss));
rvs.AppendElement(TestFailure("max-age==20032", sss));
// invalid headers
rvs.AppendElement(TestFailure("foobar", sss));
rvs.AppendElement(TestFailure("maxage=100", sss));
rvs.AppendElement(TestFailure("maxa-ge=100", sss));
rvs.AppendElement(TestFailure("max-ag=100", sss));
rvs.AppendElement(TestFailure("includesubdomains", sss));
rvs.AppendElement(TestFailure(";", sss));
rvs.AppendElement(TestFailure("max-age=\"100", sss));
// The max-age directive here doesn't conform to the spec, so it MUST
// be ignored. Consequently, the REQUIRED max-age directive is not
// present in this header, and so it is invalid.
rvs.AppendElement(TestFailure("max-age=100, max-age=200; includeSubdomains", sss));
rvs.AppendElement(TestFailure("max-age=100 includesubdomains", sss));
rvs.AppendElement(TestFailure("max-age=100 bar foo", sss));
rvs.AppendElement(TestFailure("max-age=100randomstuffhere", sss));
// All directives MUST appear only once in an STS header field.
rvs.AppendElement(TestFailure("max-age=100; max-age=200", sss));
rvs.AppendElement(TestFailure("includeSubdomains; max-age=200; includeSubdomains", sss));
rvs.AppendElement(TestFailure("max-age=200; includeSubdomains; includeSubdomains", sss));
// The includeSubdomains directive is valueless.
rvs.AppendElement(TestFailure("max-age=100; includeSubdomains=unexpected", sss));
// LWS must have at least one space or horizontal tab
rvs.AppendElement(TestFailure("\r\nmax-age=200", sss));
rv1 = rvs.Contains(false) ? 1 : 0;
if (rv1 == 0)
passed("Avoided parsing invalid STS headers");
return (rv0 + rv1);
}
// General note about return values:
// return 1 for a setup or xpcom type failure, return 2 for a real test failure
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("TestImapFlagAndUidState.cpp");
if (xpcom.failed())
return 1;
struct msgState msgState1[] = {
{10, kImapMsgSeenFlag, 0},
{15, kImapMsgSeenFlag, 1},
{16, kImapMsgSeenFlag, 2},
{17, kImapMsgSeenFlag, 3},
{18, kImapMsgSeenFlag, 4}};
nsRefPtr<nsImapFlagAndUidState> flagState = new nsImapFlagAndUidState(10);
int32_t numMsgs = sizeof(msgState1) / sizeof(msgState1[0]);
for (int32_t i = 0; i < numMsgs; i++)
flagState->AddUidFlagPair(msgState1[i].uid, msgState1[i].flag,
msgState1[i].index);
const char * error = MainChecks(flagState, msgState1, numMsgs, 0);
if (error)
{
printf("TEST-UNEXPECTED-FAIL | %s | %s\n", __FILE__, error);
return 1;
}
// Now reset all
flagState->Reset();
// This tests adding some messages to a partial uid flag state,
// i.e., CONDSTORE.
struct msgState msgState2[] = {
{68, kImapMsgSeenFlag, 69},
{71, kImapMsgSeenFlag, 70},
{73, kImapMsgSeenFlag, 71}};
numMsgs = sizeof(msgState2) / sizeof(msgState2[0]);
for (int32_t i = 0; i < numMsgs; i++)
flagState->AddUidFlagPair(msgState2[i].uid, msgState2[i].flag,
msgState2[i].index);
error = MainChecks(flagState, msgState2, numMsgs, 0);
if (error)
{
printf("TEST-UNEXPECTED-FAIL | %s | %s\n", __FILE__, error);
return 1;
}
// Reset all
flagState->Reset();
// This tests generating a uid string from a non-sequential set of
// messages where the first message is not in the flag state, but the
// missing message from the sequence is in the set. I.e., we're
// generating a uid string from 69,71, but only 70 and 71 are in
// the flag state.
struct msgState msgState3[] = {
{10, kImapMsgSeenFlag, 0},
{69, kImapMsgSeenFlag, 1},
{70, kImapMsgSeenFlag, 2},
{71, kImapMsgSeenFlag, 3}};
flagState->SetPartialUIDFetch(false);
numMsgs = sizeof(msgState3) / sizeof(msgState3[0]);
for (int32_t i = 0; i < numMsgs; i++)
flagState->AddUidFlagPair(msgState3[i].uid, msgState3[i].flag,
msgState3[i].index);
flagState->ExpungeByIndex(2);
nsCString uidString;
uint32_t msgUids[] = {69,71};
uint32_t msgCount = 2;
AllocateImapUidString(&msgUids[0], msgCount, flagState, uidString);
if (!uidString.EqualsLiteral("71"))
{
printf("TEST-UNEXPECTED-FAIL | uid String is %s, not 71 | %s\n", uidString.get(), __FILE__);
return -1;
}
// Reset all
flagState->Reset();
// This tests the middle message missing from the flag state.
struct msgState msgState4[] = {
{10, kImapMsgSeenFlag, 0},
{69, kImapMsgSeenFlag, 1},
{70, kImapMsgSeenFlag, 2},
{71, kImapMsgSeenFlag, 3},
{73, kImapMsgSeenFlag, 4}};
flagState->SetPartialUIDFetch(false);
numMsgs = sizeof(msgState4) / sizeof(msgState4[0]);
for (int32_t i = 0; i < numMsgs; i++)
flagState->AddUidFlagPair(msgState4[i].uid, msgState4[i].flag,
msgState4[i].index);
flagState->ExpungeByIndex(4);
uint32_t msgUids2[] = {69,71,73};
msgCount = 3;
nsCString uidString2;
AllocateImapUidString(&msgUids2[0], msgCount, flagState, uidString2);
if (!uidString2.EqualsLiteral("69,73"))
{
printf("TEST-UNEXPECTED-FAIL | uid String is %s, not 71 | %s\n", uidString.get(), __FILE__);
return -1;
}
printf("TEST-PASS | %s | all tests passed\n", __FILE__);
return 0;
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("TestColorNames");
if (xpcom.failed())
return 1;
nscolor rgb;
int rv = 0;
// First make sure we can find all of the tags that are supposed to
// be in the table. Futz with the case to make sure any case will
// work
for (PRUint32 index = 0 ; index < ArrayLength(kColorNames); index++) {
// Lookup color by name and make sure it has the right id
nsCString tagName(kColorNames[index]);
// Check that color lookup by name gets the right rgb value
if (!NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tagName), &rgb)) {
fail("can't find '%s'", tagName.get());
rv = 1;
}
if (rgb != kColors[index]) {
fail("name='%s' ColorNameToRGB=%x kColors[%d]=%08x",
tagName.get(), rgb, index, kColors[index]);
rv = 1;
}
// fiddle with the case to make sure we can still find it
tagName.SetCharAt(tagName.CharAt(0) - 32, 0);
if (!NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tagName), &rgb)) {
fail("can't find '%s'", tagName.get());
rv = 1;
}
if (rgb != kColors[index]) {
fail("name='%s' ColorNameToRGB=%x kColors[%d]=%08x",
tagName.get(), rgb, index, kColors[index]);
rv = 1;
}
// Check that parsing an RGB value in hex gets the right values
PRUint8 r = NS_GET_R(rgb);
PRUint8 g = NS_GET_G(rgb);
PRUint8 b = NS_GET_B(rgb);
PRUint8 a = NS_GET_A(rgb);
if (a != PR_UINT8_MAX) {
// NS_HexToRGB() can not handle a color with alpha channel
rgb = NS_RGB(r, g, b);
}
char cbuf[50];
PR_snprintf(cbuf, sizeof(cbuf), "%02x%02x%02x", r, g, b);
nscolor hexrgb;
if (!NS_HexToRGB(NS_ConvertASCIItoUTF16(cbuf), &hexrgb)) {
fail("hex conversion to color of '%s'", cbuf);
rv = 1;
}
if (hexrgb != rgb) {
fail("rgb=%x hexrgb=%x", rgb, hexrgb);
rv = 1;
}
}
// Now make sure we don't find some garbage
for (PRUint32 i = 0; i < ArrayLength(kJunkNames); i++) {
nsCString tag(kJunkNames[i]);
if (NS_ColorNameToRGB(NS_ConvertASCIItoUTF16(tag), &rgb)) {
fail("found '%s'", kJunkNames[i] ? kJunkNames[i] : "(null)");
rv = 1;
}
}
if (rv == 0)
passed("TestColorNames");
return rv;
}
int main(int argc, char* argv[])
{
ScopedXPCOM xpcom("NtPathToDosPath");
if (xpcom.failed()) {
fail("XPCOM Startup");
return 1;
}
nsAutoString cDrive;
if (!DriveToNtPath(L'C', cDrive)) {
fail("Querying for this machine's C:");
return 1;
}
int result = 0;
// empty string
if (!TestNtPathToDosPath(L"", L"")) {
fail("Empty string");
result = 1;
}
// non-existent device, must fail
if (TestNtPathToDosPath(L"\\Device\\ThisDeviceDoesNotExist\\Foo", nullptr)) {
fail("Non-existent device");
result = 1;
}
// base case
nsAutoString testPath(cDrive);
testPath.Append(L"\\Foo");
if (!TestNtPathToDosPath(testPath.get(), L"C:\\Foo")) {
fail("Base case");
result = 1;
}
// drive letters as symbolic links (NtCreateFile uses these)
if (!TestNtPathToDosPath(L"\\??\\C:\\Foo", L"C:\\Foo")) {
fail("Path specified as symbolic link");
result = 1;
}
// other symbolic links (should fail)
if (TestNtPathToDosPath(L"\\??\\MountPointManager", nullptr)) {
fail("Other symbolic link");
result = 1;
}
// socket (should fail)
if (TestNtPathToDosPath(L"\\Device\\Afd\\Endpoint", nullptr)) {
fail("Socket");
result = 1;
}
// currently UNC paths that are not mapped to drive letters are unsupported,
// so this should fail
if (TestNtPathToDosPath(L"\\Device\\Mup\\127.0.0.1\\C$", nullptr)) {
fail("Unmapped UNC path");
result = 1;
}
DriveMapping drvMapping(NS_LITERAL_STRING("\\\\127.0.0.1\\C$"));
// Only run these tests if we were able to map; some machines don't have perms
if (drvMapping.Init()) {
wchar_t expected[] = L" :\\";
expected[0] = drvMapping.GetDriveLetter();
nsAutoString networkPath;
if (!DriveToNtPath(drvMapping.GetDriveLetter(), networkPath)) {
fail("Querying network drive");
return 1;
}
networkPath += L"\\";
if (!TestNtPathToDosPath(networkPath.get(), expected)) {
fail("Mapped UNC path");
result = 1;
}
// NtPathToDosPath must correctly handle paths whose drive letter mapping has
// changed. We need to test this because the APIs called by NtPathToDosPath
// return different info if this has happened.
if (!drvMapping.ChangeDriveLetter()) {
fail("Change drive letter");
return 1;
}
expected[0] = drvMapping.GetDriveLetter();
if (!DriveToNtPath(drvMapping.GetDriveLetter(), networkPath)) {
fail("Querying second network drive");
return 1;
}
networkPath += L"\\";
if (!TestNtPathToDosPath(networkPath.get(), expected)) {
fail("Re-mapped UNC path");
result = 1;
}
}
return result;
}
int
main(int argc, char* argv[])
{
ScopedXPCOM xpcom("TestCertDB");
if (xpcom.failed()) {
fail("couldn't initialize XPCOM");
return 1;
}
{
nsCOMPtr<nsIPrefBranch> prefs(do_GetService(NS_PREFSERVICE_CONTRACTID));
if (!prefs) {
fail("couldn't get nsIPrefBranch");
return 1;
}
// When PSM initializes, it attempts to get some localized strings.
// As a result, Android flips out if this isn't set.
nsresult rv = prefs->SetBoolPref("intl.locale.matchOS", true);
if (NS_FAILED(rv)) {
fail("couldn't set pref 'intl.locale.matchOS'");
return 1;
}
nsCOMPtr<nsIX509CertDB> certdb(do_GetService(NS_X509CERTDB_CONTRACTID));
if (!certdb) {
fail("couldn't get certdb");
return 1;
}
nsCOMPtr<nsIX509CertList> certList;
rv = certdb->GetCerts(getter_AddRefs(certList));
if (NS_FAILED(rv)) {
fail("couldn't get list of certificates");
return 1;
}
nsCOMPtr<nsISimpleEnumerator> enumerator;
rv = certList->GetEnumerator(getter_AddRefs(enumerator));
if (NS_FAILED(rv)) {
fail("couldn't enumerate certificate list");
return 1;
}
bool foundBuiltIn = false;
bool hasMore = false;
while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMore)) && hasMore) {
nsCOMPtr<nsISupports> supports;
if (NS_FAILED(enumerator->GetNext(getter_AddRefs(supports)))) {
fail("couldn't get next certificate");
return 1;
}
nsCOMPtr<nsIX509Cert> cert(do_QueryInterface(supports));
if (!cert) {
fail("couldn't QI to nsIX509Cert");
return 1;
}
if (NS_FAILED(cert->GetIsBuiltInRoot(&foundBuiltIn))) {
fail("GetIsBuiltInRoot failed");
return 1;
}
if (foundBuiltIn) {
break;
}
}
if (foundBuiltIn) {
passed("successfully loaded at least one built-in certificate");
} else {
fail("didn't load any built-in certificates");
return 1;
}
} // this scopes the nsCOMPtrs
// no nsCOMPtrs are allowed to be alive when you call NS_ShutdownXPCOM
return 0;
}
int main(int argc, char** argv)
{
ScopedXPCOM xpcom("TestStaticAtoms");
if (xpcom.failed()) {
return 1;
}
TestingAtoms::AddRefAtoms();
NS_SealStaticAtomTable();
nsCOMPtr<nsIAtom> atom = NS_Atomize("foo");
if (!atom) {
fail("Didn't get an atom for foo.");
return 1;
}
if (atom->IsStaticAtom()) {
passed("foo is a static atom");
} else {
fail("foo is not a static atom.");
return 1;
}
if (atom == TestingAtoms::foo) {
passed("foo is the right pointer");
} else {
fail("foo was not the right pointer");
return 1;
}
nsIAtom* staticAtom = NS_GetStaticAtom(NS_LITERAL_STRING("foo"));
if (!staticAtom) {
fail("Did not get a static atom for foo");
return 1;
}
if (atom == staticAtom) {
passed("NS_Atomize and NS_GetStaticAtom returned the same atom.");
} else {
fail("NS_Atomize and NS_GetStaticAtom returned different atoms.");
return 1;
}
MoreTestingAtoms::AddRefAtoms();
atom = NS_Atomize("qux");
if (!atom) {
fail("Didn't get an atom for qux.");
return 1;
}
if (atom->IsStaticAtom()) {
passed("qux is a static atom");
} else {
fail("qux is not a static atom.");
return 1;
}
if (atom == MoreTestingAtoms::qux) {
passed("qux is the right pointer");
} else {
fail("qux was not the right pointer");
return 1;
}
staticAtom = NS_GetStaticAtom(NS_LITERAL_STRING("qux"));
if (staticAtom) {
fail("Got an atom for qux. The static atom table was not sealed properly.");
return 1;
}
return 0;
}