/ - Diff - Vamp Plugin Tester - Sound Software .ac.uk

         for (Plugin::FeatureSet::const_iterator fsi = fs.begin();
              fsi != fs.end(); ++fsi) {
             int output = fsi->first;
             std::cerr << "Output " << output << ":" << std::endl;
             std::cout << "Output " << output << ":" << std::endl;
             const Plugin::FeatureList &fl = fsi->second;
             for (int i = 0; i < (int)fl.size(); ++i) {
                 std::cerr << "  Feature " << i << ":" << std::endl;
                 std::cout << "  Feature " << i << ":" << std::endl;
                 const Plugin::Feature &f = fl[i];
                 std::cerr << "    Timestamp: " << (f.hasTimestamp ? "(none)" : f.timestamp.toText()) << std::endl;
                 std::cerr << "    Duration: " << (f.hasDuration ? "(none)" : f.duration.toText()) << std::endl;
                 std::cerr << "    Label: " << (f.label == "" ? "(none)" : f.label) << std::endl;
                 std::cerr << "    Value: " << (f.values.empty() ? "(none)" : "");
                 std::cout << "    Timestamp: " << (f.hasTimestamp ? "(none)" : f.timestamp.toText()) << std::endl;
                 std::cout << "    Duration: " << (f.hasDuration ? "(none)" : f.duration.toText()) << std::endl;
                 std::cout << "    Label: " << (f.label == "" ? "(none)" : f.label) << std::endl;
                 std::cout << "    Value: " << (f.values.empty() ? "(none)" : "");
                 for (int j = 0; j < (int)f.values.size(); ++j) {
                     std::cerr << f.values[j] << " ";
                     std::cout << f.values[j] << " ";
+                }
                 std::cerr << std::endl;
                 std::cout << std::endl;
+            }
+        }
+    }
-...
                const Plugin::FeatureSet &a,
                const Plugin::FeatureSet &b)
+    {
         std::cerr << r.message() << std::endl;
         std::cerr << "\nFirst result set:" << std::endl;
         std::cout << r.message() << std::endl;
         std::cout << "\nFirst result set:" << std::endl;
         dump(a);
         std::cerr << "\nSecond result set:" << std::endl;
         std::cout << "\nSecond result set:" << std::endl;
         dump(b);
         std::cerr << std::endl;
         std::cout << std::endl;
+    }
     bool

+    {
     public:
         virtual ~Test();
         enum Option {
             NoOption = 0x0,
             NonDeterministic = 0x1,
             Verbose = 0x2
         };
         typedef int Options;
         class Result {
         public:
             enum Code { Success, Note, Warning, Error };
             Result() : m_code(Success) { }
             Result(Code c, std::string m) : m_code(c), m_message(m) { }
             Code code() const { return m_code; }
             std::string message() const { return m_message; }
         protected:
             Code m_code;
             std::string m_message;
-...
         class FailedToLoadPlugin { };
         // may throw FailedToLoadPlugin
         virtual Results test(std::string key) = 0;
         virtual Results test(std::string key, Options) = 0;
     protected:
         Test();

     static const size_t _step = 1000;
     Test::Results
     TestDefaultProgram::test(string key)
     TestDefaultProgram::test(string key, Options options)
+    {
         Plugin::FeatureSet f[2];
         int rate = 44100;
-...
         if (data) destroyTestAudio(data, channels);
         if (!(f[0] == f[1])) {
             Result res = warning("Explicitly setting current program to its supposed current value changes the results");
             dump(res, f[0], f[1]);
             string message = "Explicitly setting current program to its supposed current value changes the results";
             Result res;
             if (options & NonDeterministic) res = note(message);
             else res = error(message);
             if (options & Verbose) dump(res, f[0], f[1]);
             r.push_back(res);
         } else {
             r.push_back(success());
-...
+    }
     Test::Results
     TestDefaultParameters::test(string key)
     TestDefaultParameters::test(string key, Options options)
+    {
         Plugin::FeatureSet f[2];
         int rate = 44100;
-...
         if (data) destroyTestAudio(data, channels);
         if (!(f[0] == f[1])) {
             Result res = warning("Explicitly setting parameters to their supposed default values changes the results");
             dump(res, f[0], f[1]);
             string message = "Explicitly setting parameters to their supposed default values changes the results";
             Result res;
             if (options & NonDeterministic) res = note(message);
             else res = error(message);
             if (options & Verbose) dump(res, f[0], f[1]);
             r.push_back(res);
         } else {
             r.push_back(success());
-...
+    }
     Test::Results
     TestLengthyConstructor::test(string key)
     TestLengthyConstructor::test(string key, Options options)
+    {
         time_t t0 = time(0);
         auto_ptr<Plugin> p(load(key));

+    {
     public:
         TestDefaultProgram() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestDefaultProgram> m_registrar;
-...
+    {
     public:
         TestDefaultParameters() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestDefaultParameters> m_registrar;
-...
+    {
     public:
         TestLengthyConstructor() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestLengthyConstructor> m_registrar;

TestInputExtremes.cpp
67	67	TestRandomInput::m_registrar("C6 Random input");
68	68
69	69	Test::Results
70		TestNormalInput::test(string key)
	70	TestNormalInput::test(string key, Options options)
71	71	{
72	72	Plugin::FeatureSet f;
73	73	int rate = 44100;
...	...
95	95	r.push_back(success());
96	96	} else {
97	97	r.push_back(warning("plugin returned one or more NaN/inf values"));
	98	if (options & Verbose) dump(f);
98	99	}
99	100	return r;
100	101	}
101	102
102	103	Test::Results
103		TestNoInput::test(string key)
	104	TestNoInput::test(string key, Options options)
104	105	{
105	106	auto_ptr<Plugin> p(load(key));
106	107	Results r;
...	...
116	117	}
117	118
118	119	Test::Results
119		TestShortInput::test(string key)
	120	TestShortInput::test(string key, Options options)
120	121	{
121	122	Plugin::FeatureSet f;
122	123	int rate = 44100;
...	...
141	142	r.push_back(success());
142	143	} else {
143	144	r.push_back(warning("plugin returned one or more NaN/inf values"));
	145	if (options & Verbose) dump(f);
144	146	}
145	147	return r;
146	148	}
147	149
148	150	Test::Results
149		TestSilentInput::test(string key)
	151	TestSilentInput::test(string key, Options options)
150	152	{
151	153	Plugin::FeatureSet f;
152	154	int rate = 44100;
...	...
172	174	r.push_back(success());
173	175	} else {
174	176	r.push_back(warning("plugin returned one or more NaN/inf values"));
	177	if (options & Verbose) dump(f);
175	178	}
176	179	return r;
177	180	}
178	181
179	182	Test::Results
180		TestTooLoudInput::test(string key)
	183	TestTooLoudInput::test(string key, Options options)
181	184	{
182	185	Plugin::FeatureSet f;
183	186	int rate = 44100;
...	...
205	208	r.push_back(success());
206	209	} else {
207	210	r.push_back(warning("plugin returned one or more NaN/inf values"));
	211	if (options & Verbose) dump(f);
208	212	}
209	213	return r;
210	214	}
211	215
212	216	Test::Results
213		TestRandomInput::test(string key)
	217	TestRandomInput::test(string key, Options options)
214	218	{
215	219	Plugin::FeatureSet f;
216	220	int rate = 44100;
...	...
238	242	r.push_back(success());
239	243	} else {
240	244	r.push_back(warning("plugin returned one or more NaN/inf values"));
	245	if (options & Verbose) dump(f);
241	246	}
242	247	return r;
243	248	}

+    {
     public:
         TestNormalInput() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestNormalInput> m_registrar;
-...
+    {
     public:
         TestNoInput() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestNoInput> m_registrar;
-...
+    {
     public:
         TestShortInput() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestShortInput> m_registrar;
-...
+    {
     public:
         TestSilentInput() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestSilentInput> m_registrar;
-...
+    {
     public:
         TestTooLoudInput() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestTooLoudInput> m_registrar;
-...
+    {
     public:
         TestRandomInput() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestRandomInput> m_registrar;

     static const size_t _step = 1000;
     Test::Results
     TestDistinctRuns::test(string key)
     TestDistinctRuns::test(string key, Options options)
+    {
         Plugin::FeatureSet f[2];
         int rate = 44100;
-...
         if (data) destroyTestAudio(data, channels);
         if (!(f[0] == f[1])) {
             Result res = warning("Consecutive runs with separate instances produce different results");
             dump(res, f[0], f[1]);
             Result res;
             string message = "Consecutive runs with separate instances produce different results";
             if (options & NonDeterministic) res = note(message);
             else res = error(message);
             if (options & Verbose) dump(res, f[0], f[1]);
             r.push_back(res);
         } else {
             r.push_back(success());
-...
+    }
     Test::Results
     TestReset::test(string key)
     TestReset::test(string key, Options options)
+    {
         Plugin::FeatureSet f[2];
         int rate = 44100;
-...
         if (data) destroyTestAudio(data, channels);
         if (!(f[0] == f[1])) {
             Result res = warning("Consecutive runs with the same instance (using reset) produce different results");
             dump(res, f[0], f[1]);
             string message = "Consecutive runs with the same instance (using reset) produce different results";
             Result res;
             if (options & NonDeterministic) res = note(message);
             else res = error(message);
             if (options & Verbose) dump(res, f[0], f[1]);
             r.push_back(res);
         } else {
             r.push_back(success());
-...
+    }
     Test::Results
     TestInterleavedRuns::test(string key)
     TestInterleavedRuns::test(string key, Options options)
+    {
         Plugin::FeatureSet f[2];
         int rate = 44100;
-...
         if (data) destroyTestAudio(data, channels);
         if (!(f[0] == f[1])) {
             Result res = warning("Simultaneous runs with separate instances produce different results");
             dump(res, f[0], f[1]);
             string message = "Simultaneous runs with separate instances produce different results";
             Result res;
             if (options & NonDeterministic) res = note(message);
             else res = error(message);
             if (options & Verbose) dump(res, f[0], f[1]);
             r.push_back(res);
         } else {
             r.push_back(success());
-...
+    }
     Test::Results
     TestDifferentStartTimes::test(string key)
     TestDifferentStartTimes::test(string key, Options options)
+    {
         Plugin::FeatureSet f[2];
         int rate = 44100;
-...
         if (data) destroyTestAudio(data, channels);
         if (f[0] == f[1]) {
             Result res = warning("Consecutive runs with different starting timestamps produce the same result");
             dump(res, f[0], f[1]);
             string message = "Consecutive runs with different starting timestamps produce the same result";
             Result res;
             if (options & NonDeterministic) res = note(message);
             else res = error(message);
             if (options & Verbose) dump(res, f[0], f[1]);
             r.push_back(res);
         } else {
             r.push_back(success());

+    {
     public:
         TestDistinctRuns() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestDistinctRuns> m_registrar;
-...
+    {
     public:
         TestReset() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestReset> m_registrar;
-...
+    {
     public:
         TestInterleavedRuns() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestInterleavedRuns> m_registrar;
-...
+    {
     public:
         TestDifferentStartTimes() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestDifferentStartTimes> m_registrar;

TestOutputs.cpp
59	59	static const size_t _step = 1000;
60	60
61	61	Test::Results
62		TestOutputNumbers::test(string key)
	62	TestOutputNumbers::test(string key, Options options)
63	63	{
64	64	int rate = 44100;
65	65	auto_ptr<Plugin> p(load(key, rate));
...	...
99	99	}
100	100	}
101	101
	102	if (!r.empty() && (options & Verbose)) dump(f);
102	103	return r;
103	104	}
104	105
105	106	Test::Results
106		TestTimestamps::test(string key)
	107	TestTimestamps::test(string key, Options options)
107	108	{
108	109	int rate = 44100;
109	110
...	...
159	160	}
160	161	}
161	162
	163	if (!r.empty() && (options & Verbose)) dump(f);
162	164	return r;
163	165	}

+    {
     public:
         TestOutputNumbers() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestOutputNumbers> m_registrar;
-...
+    {
     public:
         TestTimestamps() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestTimestamps> m_registrar;

TestStaticData.cpp
57	57	TestValueRanges::m_registrar("A3 Inappropriate value extents");
58	58
59	59	Test::Results
60		TestIdentifiers::test(string key)
	60	TestIdentifiers::test(string key, Options options)
61	61	{
62	62	auto_ptr<Plugin> p(load(key));
63	63
...	...
94	94	}
95	95
96	96	Test::Results
97		TestEmptyFields::test(string key)
	97	TestEmptyFields::test(string key, Options options)
98	98	{
99	99	auto_ptr<Plugin> p(load(key));
100	100
...	...
147	147	}
148	148
149	149	Test::Results
150		TestValueRanges::test(string key)
	150	TestValueRanges::test(string key, Options options)
151	151	{
152	152	auto_ptr<Plugin> p(load(key));
153	153

+    {
     public:
         TestIdentifiers() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         Result testIdentifier(std::string ident, std::string desc);
-...
+    {
     public:
         TestEmptyFields() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         Result testMandatory(std::string text, std::string desc);
-...
+    {
     public:
         TestValueRanges() : Test() { }
         Results test(std::string key);
         Results test(std::string key, Options options);
     protected:
         static Tester::TestRegistrar<TestValueRanges> m_registrar;

     using namespace std;
     Tester::Tester(std::string key) :
         m_key(key)
     Tester::Tester(std::string key, Test::Options options) :
         m_key(key),
         m_options(options)
+    {
+    }
-...
                 std::cout << " -- Performing test: " << i->first << std::endl;
                 Test *test = i->second->makeTest();
                 Test::Results results = test->test(m_key);
                 Test::Results results = test->test(m_key, m_options);
                 delete test;
                 set<string> printed;

     class Tester
+    {
     public:
         Tester(std::string pluginKey);
         Tester(std::string pluginKey, Test::Options);
         ~Tester();
         bool test(int &notes, int &warnings, int &errors);
-...
     protected:
         std::string m_key;
         Test::Options m_options;
         typedef std::map<std::string, Registrar *> Registry;
         static Registry &registry();
     };

     #include <iostream>
     #include <cstdlib>
     #include <cstring>
     #include "Tester.h"
-...
             "Copyright 2009 QMUL.\n"
             "Freely redistributable; published under a BSD-style license.\n\n"
             "Usage:\n"
             "  " << name << " [<pluginbasename>:<plugin>]\n\n"
             "  " << name << " [-n] [-v] [<pluginbasename>:<plugin>]\n\n"
             "Example:\n"
             "  " << name << " vamp-example-plugins:amplitudefollower\n\n"
             "With an argument, tests one plugin; without, tests all plugins in Vamp path.\n"
             "If you have access to a runtime memory checker, you may find it especially\n"
             "\nOptions:\n"
             "  --nondeterministic, -n    Plugins may be nondeterministic: print a note\n"
             "                            instead of an error if results differ between runs\n"
             "  --verbose, -v             Show returned features each time a note, warning,\n"
             "                            or error arises from feature data\n"
             "\nIf you have access to a runtime memory checker, you may find it especially\n"
             "helpful to run this tester under it and watch for errors thus provoked.\n"
              << endl;
         exit(2);
-...
             else ++scooter;
+        }
         if (!name || !*name) name = argv[0];
         bool nondeterministic = false;
         bool verbose = false;
         string argument;
         for (int i = 1; i < argc; ++i) {
             if (!argv[i]) break;
             if (argv[i][0] == '-') {
                 if (!strcmp(argv[i], "-v") ||
                     !strcmp(argv[i], "--verbose")) {
                     verbose = 1;
                     continue;
+                }
                 if (!strcmp(argv[i], "-n") ||
                     !strcmp(argv[i], "--nondeterministic")) {
                     nondeterministic = 1;
                     continue;
+                }
                 usage(name);
             } else {
                 if (argument != "") usage(name);
                 else argument = argv[i];
+            }
+        }
         if (argc > 2) usage(name);
         if (argc == 2 && argv[1][0] == '-') usage(name);
         cerr << name << ": Running..." << endl;
         if (argc == 1) {
         Test::Options opts = Test::NoOption;
         if (nondeterministic) opts |= Test::NonDeterministic;
         if (verbose) opts |= Test::Verbose;
         if (argument == "") {
             bool good = true;
             Vamp::HostExt::PluginLoader::PluginKeyList keys =
                 Vamp::HostExt::PluginLoader::getInstance()->listPlugins();
             int notes = 0, warnings = 0, errors = 0;
             for (int i = 0; i < (int)keys.size(); ++i) {
                 cout << "Testing plugin: " << keys[i] << endl;
                 Tester tester(keys[i]);
                 Tester tester(keys[i], opts);
                 if (tester.test(notes, warnings, errors)) {
                     cout << name << ": All tests succeeded for this plugin" << endl;
                 } else {
-...
                 return 1;
+            }
         } else {
             string key = argv[1];
             Tester tester(key);
             string key = argument;
             Tester tester(key, opts);
             int notes = 0, warnings = 0, errors = 0;
             if (tester.test(notes, warnings, errors)) {
                 cout << name << ": All tests succeeded";

Vamp »

Vamp Plugin Tester

Revision 8:3019cb6b538d