src/testcases/GigWriteTest.cpp

#include "GigWriteTest.h"

#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>

#include "../gig.h"

CPPUNIT_TEST_SUITE_REGISTRATION(GigWriteTest);

using namespace std;

// file name of the Gigasampler file we are going to create for these tests
#define TEST_GIG_FILE_NAME "foo.gig"

// four stupid little sample "waves"
// (each having three sample points length, 16 bit depth, mono)
int16_t sampleData1[] = { 1, 2, 3 };
int16_t sampleData2[] = { 4, 5, 6 };
int16_t sampleData3[] = { 7, 8, 9 };
int16_t sampleData4[] = { 10,11,12 };

void GigWriteTest::printTestSuiteName() {
    cout << "\b \nTesting Gigasampler write support: " << flush;
}

// code executed when this test suite is created
void GigWriteTest::setUp() {
}

// code executed when this test suite will be destroyed
void GigWriteTest::tearDown() {
}


/////////////////////////////////////////////////////////////////////////////
// The actual test cases (in order) ...

// 1.) create a new Gigasampler file from scratch
void GigWriteTest::createNewGigFile() {
    try {
        // create an empty Gigasampler file
        gig::File file;
        // we give it an internal name, not mandatory though
        file.pInfo->Name = "Foo Gigasampler File";

        // create four samples
        gig::Sample* pSample1 = file.AddSample();
        gig::Sample* pSample2 = file.AddSample();
        gig::Sample* pSample3 = file.AddSample();
        gig::Sample* pSample4 = file.AddSample();
        // give those samples a name (not mandatory)
        pSample1->pInfo->Name = "Foo Sample 1";
        pSample2->pInfo->Name = "Foo Sample 2";
        pSample3->pInfo->Name = "Foo Sample 3";
        pSample4->pInfo->Name = "Foo Sample 4";
        // set meta informations for those samples
        pSample1->Channels = 1; // mono
        pSample1->BitDepth = 16; // 16 bits
        pSample1->FrameSize = 16/*bitdepth*/ / 8/*1 byte are 8 bits*/ * 1/*mono*/;
        pSample1->SamplesPerSecond = 44100;
        pSample2->Channels = 1; // mono
        pSample2->BitDepth = 16; // 16 bits
        pSample2->FrameSize = 16 / 8 * 1;
        pSample2->SamplesPerSecond = 44100;
        pSample3->Channels = 1; // mono
        pSample3->BitDepth = 16; // 16 bits
        pSample3->FrameSize = 16 / 8 * 1;
        pSample3->SamplesPerSecond = 44100;
        pSample4->Channels = 1; // mono
        pSample4->BitDepth = 16; // 16 bits
        pSample4->FrameSize = 16 / 8 * 1;
        pSample4->SamplesPerSecond = 44100;
        // resize those samples to a length of three sample points
        // (again: _sample_points_ NOT bytes!) which is the length of our
        // ficticious samples from above. after the Save() call below we can
        // then directly write our sample data to disk by using the Write()
        // method, that is without having to load all the sample data into
        // RAM. for large instruments / .gig files this is definitely the way
        // to go
        pSample1->Resize(3);
        pSample2->Resize(3);
        pSample3->Resize(3);
        pSample4->Resize(3);

        // create four instruments
        gig::Instrument* pInstrument1 = file.AddInstrument();
        gig::Instrument* pInstrument2 = file.AddInstrument();
        gig::Instrument* pInstrument3 = file.AddInstrument();
        gig::Instrument* pInstrument4 = file.AddInstrument();
        // give them a name (not mandatory)
        pInstrument1->pInfo->Name = "Foo Instrument 1";
        pInstrument2->pInfo->Name = "Foo Instrument 2";
        pInstrument3->pInfo->Name = "Foo Instrument 3";
        pInstrument4->pInfo->Name = "Foo Instrument 4";

        // create one region for each instrument
        // in this example we do not add a dimension, so
        // every region will have exactly one DimensionRegion
        // also we assign a sample to each dimension region
        gig::Region* pRegion = pInstrument1->AddRegion();
        pRegion->SetSample(pSample1);
        pRegion->pDimensionRegions[0]->pSample = pSample1;

        pRegion = pInstrument2->AddRegion();
        pRegion->SetSample(pSample2);
        pRegion->pDimensionRegions[0]->pSample = pSample2;

        pRegion = pInstrument3->AddRegion();
        pRegion->SetSample(pSample3);
        pRegion->pDimensionRegions[0]->pSample = pSample3;

        pRegion = pInstrument4->AddRegion();
        pRegion->SetSample(pSample4);
        pRegion->pDimensionRegions[0]->pSample = pSample4;

        // save file ("physically") as of now
        file.Save(TEST_GIG_FILE_NAME);
    } catch (RIFF::Exception e) {
        std::cerr << "\nCould not create a new Gigasampler file from scratch:\n" << std::flush;
        e.PrintMessage();
        throw e; // stop further tests
    }
}

// 2.) test if the newly created Gigasampler file exists & can be opened
void GigWriteTest::testOpenCreatedGigFile() {
    // try to open previously created Gigasampler file
    try {
        RIFF::File riff(TEST_GIG_FILE_NAME);
        gig::File file(&riff);
    } catch (RIFF::Exception e) {
        std::cerr << "\nCould not open newly created Gigasampler file:\n" << std::flush;
        e.PrintMessage();
        throw e; // stop further tests
    }
}

// 3.) test if the articulation informations of the newly created Gigasampler file were correctly written
void GigWriteTest::testArticulationsOfCreatedGigFile() {
    try {
        // open previously created Gigasampler file
        RIFF::File riff(TEST_GIG_FILE_NAME);
        gig::File file(&riff);
        // check amount of instruments and samples
        CPPUNIT_ASSERT(file.Instruments == 4);
        int iSamples = 0;
        for (gig::Sample* pSample = file.GetFirstSample(); pSample; pSample = file.GetNextSample()) iSamples++;
        CPPUNIT_ASSERT(iSamples == 4);

        //TODO: check all articulations previously set in createNewGigFile()

    } catch (RIFF::Exception e) {
        std::cerr << "\nThere was an exception while checking the articulation data of the newly created Gigasampler file:\n" << std::flush;
        e.PrintMessage();
        throw e; // stop further tests
    }
}

// 4.) try to write sample data to that newly created Gigasampler file
void GigWriteTest::testWriteSamples() {
    try {
        // open previously created Gigasampler file
        RIFF::File riff(TEST_GIG_FILE_NAME);
        gig::File file(&riff);
        // until this point we just wrote the articulation data to the .gig file
        // and prepared the .gig file for writing our 4 example sample data, so
        // now as the file exists physically and the 'samples' are already
        // of the correct size we can now write the actual samples' data by
        // directly writing them to disk
        gig::Sample* pSample1 = file.GetFirstSample();
        gig::Sample* pSample2 = file.GetNextSample();
        gig::Sample* pSample3 = file.GetNextSample();
        gig::Sample* pSample4 = file.GetNextSample();
        CPPUNIT_ASSERT(pSample1);
        pSample1->Write(sampleData1, 3);
        CPPUNIT_ASSERT(pSample2);
        pSample2->Write(sampleData2, 3);
        CPPUNIT_ASSERT(pSample3);
        pSample3->Write(sampleData3, 3);
        CPPUNIT_ASSERT(pSample4);
        pSample4->Write(sampleData4, 3);
    } catch (RIFF::Exception e) {
        std::cerr << "\nCould not directly write samples to newly created Gigasampler file:\n" << std::flush;
        e.PrintMessage();
        throw e; // stop further tests
    }
}
1	schoenebeck	917	#include "GigWriteTest.h"
2
3			#include <iostream>
4			#include <stdlib.h>
5			#include <stdio.h>
6			#include <string.h>
7
8			#include "../gig.h"
9
10			CPPUNIT_TEST_SUITE_REGISTRATION(GigWriteTest);
11
12			using namespace std;
13
14			// file name of the Gigasampler file we are going to create for these tests
15			#define TEST_GIG_FILE_NAME "foo.gig"
16
17			// four stupid little sample "waves"
18			// (each having three sample points length, 16 bit depth, mono)
19			int16_t sampleData1[] = { 1, 2, 3 };
20			int16_t sampleData2[] = { 4, 5, 6 };
21			int16_t sampleData3[] = { 7, 8, 9 };
22			int16_t sampleData4[] = { 10,11,12 };
23
24			void GigWriteTest::printTestSuiteName() {
25			cout << "\b \nTesting Gigasampler write support: " << flush;
26			}
27
28			// code executed when this test suite is created
29			void GigWriteTest::setUp() {
30			}
31
32			// code executed when this test suite will be destroyed
33			void GigWriteTest::tearDown() {
34			}
35
36
37			/////////////////////////////////////////////////////////////////////////////
38			// The actual test cases (in order) ...
39
40			// 1.) create a new Gigasampler file from scratch
41			void GigWriteTest::createNewGigFile() {
42			try {
43			// create an empty Gigasampler file
44			gig::File file;
45			// we give it an internal name, not mandatory though
46			file.pInfo->Name = "Foo Gigasampler File";
47
48			// create four samples
49			gig::Sample* pSample1 = file.AddSample();
50			gig::Sample* pSample2 = file.AddSample();
51			gig::Sample* pSample3 = file.AddSample();
52			gig::Sample* pSample4 = file.AddSample();
53			// give those samples a name (not mandatory)
54			pSample1->pInfo->Name = "Foo Sample 1";
55			pSample2->pInfo->Name = "Foo Sample 2";
56			pSample3->pInfo->Name = "Foo Sample 3";
57			pSample4->pInfo->Name = "Foo Sample 4";
58			// set meta informations for those samples
59			pSample1->Channels = 1; // mono
60			pSample1->BitDepth = 16; // 16 bits
61			pSample1->FrameSize = 16/bitdepth/ / 8/1 byte are 8 bits/ * 1/mono/;
62			pSample1->SamplesPerSecond = 44100;
63			pSample2->Channels = 1; // mono
64			pSample2->BitDepth = 16; // 16 bits
65			pSample2->FrameSize = 16 / 8 * 1;
66			pSample2->SamplesPerSecond = 44100;
67			pSample3->Channels = 1; // mono
68			pSample3->BitDepth = 16; // 16 bits
69			pSample3->FrameSize = 16 / 8 * 1;
70			pSample3->SamplesPerSecond = 44100;
71			pSample4->Channels = 1; // mono
72			pSample4->BitDepth = 16; // 16 bits
73			pSample4->FrameSize = 16 / 8 * 1;
74			pSample4->SamplesPerSecond = 44100;
75			// resize those samples to a length of three sample points
76			// (again: _sample_points_ NOT bytes!) which is the length of our
77			// ficticious samples from above. after the Save() call below we can
78			// then directly write our sample data to disk by using the Write()
79			// method, that is without having to load all the sample data into
80			// RAM. for large instruments / .gig files this is definitely the way
81			// to go
82			pSample1->Resize(3);
83			pSample2->Resize(3);
84			pSample3->Resize(3);
85			pSample4->Resize(3);
86
87			// create four instruments
88			gig::Instrument* pInstrument1 = file.AddInstrument();
89			gig::Instrument* pInstrument2 = file.AddInstrument();
90			gig::Instrument* pInstrument3 = file.AddInstrument();
91			gig::Instrument* pInstrument4 = file.AddInstrument();
92			// give them a name (not mandatory)
93			pInstrument1->pInfo->Name = "Foo Instrument 1";
94			pInstrument2->pInfo->Name = "Foo Instrument 2";
95			pInstrument3->pInfo->Name = "Foo Instrument 3";
96			pInstrument4->pInfo->Name = "Foo Instrument 4";
97
98			// create one region for each instrument
99			// in this example we do not add a dimension, so
100			// every region will have exactly one DimensionRegion
101			// also we assign a sample to each dimension region
102			gig::Region* pRegion = pInstrument1->AddRegion();
103			pRegion->SetSample(pSample1);
104			pRegion->pDimensionRegions[0]->pSample = pSample1;
105
106			pRegion = pInstrument2->AddRegion();
107			pRegion->SetSample(pSample2);
108			pRegion->pDimensionRegions[0]->pSample = pSample2;
109
110			pRegion = pInstrument3->AddRegion();
111			pRegion->SetSample(pSample3);
112			pRegion->pDimensionRegions[0]->pSample = pSample3;
113
114			pRegion = pInstrument4->AddRegion();
115			pRegion->SetSample(pSample4);
116			pRegion->pDimensionRegions[0]->pSample = pSample4;
117
118			// save file ("physically") as of now
119			file.Save(TEST_GIG_FILE_NAME);
120			} catch (RIFF::Exception e) {
121			std::cerr << "\nCould not create a new Gigasampler file from scratch:\n" << std::flush;
122			e.PrintMessage();
123			throw e; // stop further tests
124			}
125			}
126
127			// 2.) test if the newly created Gigasampler file exists & can be opened
128			void GigWriteTest::testOpenCreatedGigFile() {
129			// try to open previously created Gigasampler file
130			try {
131			RIFF::File riff(TEST_GIG_FILE_NAME);
132			gig::File file(&riff);
133			} catch (RIFF::Exception e) {
134			std::cerr << "\nCould not open newly created Gigasampler file:\n" << std::flush;
135			e.PrintMessage();
136			throw e; // stop further tests
137			}
138			}
139
140			// 3.) test if the articulation informations of the newly created Gigasampler file were correctly written
141			void GigWriteTest::testArticulationsOfCreatedGigFile() {
142			try {
143			// open previously created Gigasampler file
144			RIFF::File riff(TEST_GIG_FILE_NAME);
145			gig::File file(&riff);
146			// check amount of instruments and samples
147			CPPUNIT_ASSERT(file.Instruments == 4);
148			int iSamples = 0;
149			for (gig::Sample* pSample = file.GetFirstSample(); pSample; pSample = file.GetNextSample()) iSamples++;
150			CPPUNIT_ASSERT(iSamples == 4);
151
152			//TODO: check all articulations previously set in createNewGigFile()
153
154			} catch (RIFF::Exception e) {
155			std::cerr << "\nThere was an exception while checking the articulation data of the newly created Gigasampler file:\n" << std::flush;
156			e.PrintMessage();
157			throw e; // stop further tests
158			}
159			}
160
161			// 4.) try to write sample data to that newly created Gigasampler file
162			void GigWriteTest::testWriteSamples() {
163			try {
164			// open previously created Gigasampler file
165			RIFF::File riff(TEST_GIG_FILE_NAME);
166			gig::File file(&riff);
167			// until this point we just wrote the articulation data to the .gig file
168			// and prepared the .gig file for writing our 4 example sample data, so
169			// now as the file exists physically and the 'samples' are already
170			// of the correct size we can now write the actual samples' data by
171			// directly writing them to disk
172			gig::Sample* pSample1 = file.GetFirstSample();
173			gig::Sample* pSample2 = file.GetNextSample();
174			gig::Sample* pSample3 = file.GetNextSample();
175			gig::Sample* pSample4 = file.GetNextSample();
176			CPPUNIT_ASSERT(pSample1);
177			pSample1->Write(sampleData1, 3);
178			CPPUNIT_ASSERT(pSample2);
179			pSample2->Write(sampleData2, 3);
180			CPPUNIT_ASSERT(pSample3);
181			pSample3->Write(sampleData3, 3);
182			CPPUNIT_ASSERT(pSample4);
183			pSample4->Write(sampleData4, 3);
184			} catch (RIFF::Exception e) {
185			std::cerr << "\nCould not directly write samples to newly created Gigasampler file:\n" << std::flush;
186			e.PrintMessage();
187			throw e; // stop further tests
188			}
189			}