testall

 $Id: testall.m,v 1.11 2004/05/14 20:15:28 stuver Exp $

0001 function gravenPass = testall
0002 
0003 % $Id: testall.m,v 1.11 2004/05/14 20:15:28 stuver Exp $
0004 
0005 addpath ../
0006 
0007 now = fix(clock);
0008 fileName = ['gravenBuildTest_' num2str(now(2)) '_' num2str(now(3)) ...
0009         '_' num2str(now(1)) '.txt'];
0010 
0011 fid = fopen(fileName, 'a');
0012 fprintf(1, ['# This GravEn build test was run on %2.0f/%2.0f/%4.0f '...
0013         'at %2.0f:%2.0f:%2.0f\n'], now(2), now(3), now(1), now(4), ...
0014     now(5), now(6));
0015 fprintf(fid, ['# This GravEn build test was run on %2.0f/%2.0f/%4.0f '...
0016         'at %2.0f:%2.0f:%2.0f\n'], now(2), now(3), now(1), now(4), ...
0017     now(5), now(6));
0018 
0019 TOLERANCE = 10*eps;
0020 
0021 failCounter = 0;
0022 
0023 % Load refernce data:
0024 load ./refData/gravenData7May2004.mat
0025 load ./refData/makelistData6May2004.mat
0026 load ./refData/ifodelayData21Apr2004.mat
0027 load ./refData/makehData5May2004.mat
0028 load ./refData/detprojData21Apr2004.mat
0029 
0030 gpsTime = 729273660;
0031 
0032 % graven
0033 
0034 % Test that the log file can be read as input file
0035 SimInput = graven('log.txt', gpsTime, 'H1', 'testopt.txt', 16384, 123);
0036 SimOutput = graven('relog.txt', gpsTime, 'H1', 'log.txt', 16384, 123);
0037 
0038 difSig1 = SimOutput(1).sig - SimInput(1).sig;
0039 difSig2 = SimOutput(end).sig - SimInput(end).sig;
0040 
0041 if abs(difSig1) > TOLERANCE | abs(difSig2) > TOLERANCE
0042     failCounter = failCounter+1;
0043     fprintf(1, 'FAIL: graven, original waveform logfile as input file \n')
0044     fprintf(fid, 'FAIL: graven, original waveform logfile as input file \n');
0045 else
0046     fprintf(1, 'PASS: graven, original waveform logfile as input file \n')
0047     fprintf(fid, 'PASS: graven, original waveform logfile as input file \n');
0048 end
0049 
0050 delete log.txt relog.txt
0051 
0052 % Test that the log file can be read as input file
0053 SimPreGenIn = graven(10,'pregenlog.txt', gpsTime, 'H1', {'./refData/ZM_A1B1G1.ilwd', 'm1.real_8'}, [1 2], 'random', 16384, 123);
0054 SimPreGenOut = graven('repregenlog.txt', gpsTime, 'H1', 'pregenlog.txt', 16384, 123);
0055 
0056 difSigPreGen1 = SimPreGenOut(1).sig - SimPreGenIn(1).sig;
0057 difSigPreGen2 = SimPreGenOut(end).sig - SimPreGenIn(end).sig;
0058 
0059 if abs(difSigPreGen1) > TOLERANCE | abs(difSigPreGen2) > TOLERANCE
0060     failCounter = failCounter+1;
0061     fprintf(1, 'FAIL: graven, pre-generated waveform logfile as input file \n')
0062     fprintf(fid, 'FAIL: graven, pre-generated waveform logfile as input file \n');
0063 else
0064     fprintf(1, 'PASS: graven, pre-generated waveform logfile as input file \n')
0065     fprintf(fid, 'PASS: graven, pre-generated waveform logfile as input file \n');
0066 end
0067 
0068 delete pregenlog.txt repregenlog.txt
0069 
0070 % Mode 1
0071 
0072 Sim1Test = graven('mode1.txt', gpsTime, 'H1', 'testopt.txt', 16384, 123);
0073 
0074 difSim11 = Sim1(1).sig - Sim1Test(1).sig;
0075 difSim12 = Sim1(end).sig - Sim1Test(end).sig;
0076 
0077 if abs(difSim11) > TOLERANCE | abs(difSim12) > TOLERANCE
0078     failCounter = failCounter+1;
0079     fprintf(1, 'FAIL: graven, mode 1 (read line-by-line from file) \n')
0080     fprintf(fid, 'FAIL: graven, mode 1 (read line-by-line from file) \n');
0081 else
0082     fprintf(1, 'PASS: graven, mode 1 (read line-by-line from file) \n')
0083     fprintf(fid, 'PASS: graven, mode 1 (read line-by-line from file) \n');
0084 end
0085 
0086 Sim2Test = graven(10, 'mode2.txt', gpsTime, 'H2', 'testopt.txt', 16384, 123);
0087 
0088 difSim21 = Sim2(1).sig - Sim2Test(1).sig;
0089 difSim22 = Sim2(end).sig - Sim2Test(end).sig;
0090 
0091 if abs(difSim21) > TOLERANCE | abs(difSim22) > TOLERANCE
0092     failCounter = failCounter+1;
0093     fprintf(1, 'FAIL: graven, mode 2 (make N random draws on file) \n')
0094     fprintf(fid, 'FAIL: graven, mode 2 (make N random draws on file) \n');
0095 else
0096     fprintf(1, 'PASS: graven, mode 2 (make N random draws on file) \n')
0097     fprintf(fid, 'PASS: graven, mode 2 (make N random draws on file) \n');
0098 end
0099 
0100 Sim3Test = graven(10, 'mode3.txt', 729273660, 'L1', 'CG_512_0.01_0.2', ...
0101     1e-21, [1 2], 'RANDOM', 'OPTIMAL', 16384, 123);
0102 
0103 difSim31 = Sim3(1).sig - Sim3Test(1).sig;
0104 difSim32 = Sim3(end).sig - Sim3Test(end).sig;
0105 
0106 if abs(difSim31) > TOLERANCE | abs(difSim32) > TOLERANCE
0107     failCounter = failCounter+1;
0108     fprintf(1, 'FAIL: graven, mode 3 (all user input) \n')
0109     fprintf(fid, 'FAIL: graven, mode 3 (all user input) \n');
0110 else
0111     fprintf(1, 'PASS: graven, mode 3 (all user input) \n')
0112     fprintf(fid, 'PASS: graven, mode 3 (all user input) \n');
0113 end
0114 
0115 delete mode1.txt mode2.txt mode3.txt
0116 
0117 SimIlwd1Test = graven(1,'mode4.txt', 729273660, 'H1', ...
0118     './refData/ZM_A1B1G1.ilwd', [1 2], 'optimal', 16384, 123);
0119 SimIlwd2Test = graven(1,'mode4.txt', 729273660, 'H1', ...
0120     {'./refData/ZM_A1B1G1.ilwd', 'm1.real_8'}, [1 2], 'optimal', 16384, 123);
0121 
0122 difSimIlwd1 = SimIlwd1(1).sig - SimIlwd1Test(1).sig;
0123 difSimIlwd2 = SimIlwd1(1).sig - SimIlwd2Test(1).sig;
0124 
0125 if abs(difSimIlwd1) > TOLERANCE | abs(difSimIlwd2) > TOLERANCE
0126     failCounter = failCounter+1;
0127     fprintf(1, 'FAIL: graven, mode 4, ilwd (pre-generated waveform) \n')
0128     fprintf(fid, 'FAIL: graven, mode 4, ilwd (pre-generated waveform) \n');
0129 else
0130     fprintf(1, 'PASS: graven, mode 4, ilwd (pre-generated waveform) \n')
0131     fprintf(fid, 'PASS: graven, mode 4, ilwd (pre-generated waveform) \n');
0132 end
0133 
0134 SimTxt1Test = graven(1,'mode4.txt', 729273660, 'H1', ...
0135     './refData/pregentest.txt', [1 2], 'optimal', 16384, 123);
0136 SimTxt2Test = graven(1,'mode4.txt', 729273660, 'H1', ...
0137     {'./refData/pregentest.txt', 'pregentest'}, [1 2], 'optimal', 16384, 123);
0138 
0139 difSimTxt1 = SimTxt1(1).sig - SimTxt1Test(1).sig;
0140 difSimTxt2 = SimTxt1(1).sig - SimTxt2Test(1).sig;
0141 
0142 if abs(difSimTxt1) > TOLERANCE | abs(difSimTxt2) > TOLERANCE
0143     failCounter = failCounter+1;
0144     fprintf(1, 'FAIL: graven, mode 4, txt (pre-generated waveform) \n')
0145     fprintf(fid, 'FAIL: graven, mode 4, txt (pre-generated waveform) \n');
0146 else
0147     fprintf(1, 'PASS: graven, mode 4, txt (pre-generated waveform) \n')
0148     fprintf(fid, 'PASS: graven, mode 4, txt (pre-generated waveform) \n');
0149 end
0150 
0151 % The following code is commented out since the GravEn code needed to
0152 % comple this will not work (however, it will work perfectly fine in the
0153 % MATLAB environment):
0154 % SimMat1Test = graven(1,'mode4.txt', 729273660, 'H1', ...
0155 %    './refData/pregentest.mat', [1 2], 'optimal', 16384, 123);
0156 % SimMat2Test = graven(1,'mode4.txt', 729273660, 'H1', ...
0157 %     {'./refData/pregentest.mat', 'pregentest'}, [1 2], 'optimal', 16384, 123);
0158 %
0159 % difSimMat1 = SimMat1(1).sig - SimMat1Test(1).sig;
0160 % difSimMat2 = SimMat1(1).sig - SimMat2Test(1).sig;
0161 %
0162 % if abs(difSimMat1) > TOLERANCE | abs(difSimMat2) > TOLERANCE
0163 %     failCounter = failCounter+1;
0164 %     fprintf(1, 'FAIL: graven, mode 4, mat (pre-generated waveform) \n')
0165 %     fprintf(fid, 'FAIL: graven, mode 4, mat (pre-generated waveform) \n');
0166 % else
0167 %     fprintf(1, 'PASS: graven, mode 4, mat (pre-generated waveform) \n')
0168 %     fprintf(fid, 'PASS: graven, mode 4, mat (pre-generated waveform) \n');
0169 % end
0170 
0171 delete mode4.txt
0172 
0173 % makelist
0174 
0175 % Mode 1
0176 rand('state', seed);
0177 mode1Test = makelist('testrand.txt');
0178 
0179 if ~isequal(mode1,mode1Test)
0180     failCounter = failCounter+1;
0181     fprintf(1, ['FAIL: makelist, mode 1 \n'])
0182     fprintf(fid, ['FAIL: makelist, mode 1 \n']);
0183 else
0184     fprintf(1, ['PASS: makelist, mode 1 \n'])
0185     fprintf(fid, ['PASS: makelist, mode 1 \n']);
0186 end
0187 
0188 
0189 % Mode 2
0190 rand('state', seed);
0191 mode2Test = makelist(N, 'testrand.txt');
0192 
0193 if ~isequal(mode2,mode2Test)
0194     failCounter = failCounter+1;
0195     fprintf(1, ['FAIL: makelist, mode 2 \n'])
0196     fprintf(fid, ['FAIL: makelist, mode 2 \n']);
0197 else
0198     fprintf(1, ['PASS: makelist, mode 2 \n'])
0199     fprintf(fid, ['PASS: makelist, mode 2 \n']);
0200 end
0201 
0202 % Mode 3
0203 rand('state', seed);
0204 mode3H1Test = makelist('testopt.txt', 'H1');
0205 rand('state', seed);
0206 mode3H2Test = makelist('testopt.txt', 'H2');
0207 rand('state', seed);
0208 mode3L1Test = makelist('testopt.txt', 'L1');
0209 
0210 if ~isequal(mode3H1,mode3H1Test)
0211     failCounter = failCounter+1;
0212     fprintf(1, ['FAIL: makelist, mode 3, H1 \n'])
0213     fprintf(fid, ['FAIL: makelist, mode 3, H1 \n']);
0214 else
0215     fprintf(1, ['PASS: makelist, mode 3, H1 \n'])
0216     fprintf(fid, ['PASS: makelist, mode 3, H1 \n']);
0217 end
0218 
0219 if ~isequal(mode3H2,mode3H2Test)
0220     failCounter = failCounter+1;
0221     fprintf(1, ['FAIL: makelist, mode 3, H2 \n'])
0222     fprintf(fid, ['FAIL: makelist, mode 3, H2 \n']);
0223 else
0224     fprintf(1, ['PASS: makelist, mode 3, H2 \n'])
0225     fprintf(fid, ['PASS: makelist, mode 3, H2 \n']);
0226 end
0227 
0228 if ~isequal(mode3L1,mode3L1Test)
0229     failCounter = failCounter+1;
0230     fprintf(1, ['FAIL: makelist, mode 3, L1 \n'])
0231     fprintf(fid, ['FAIL: makelist, mode 3, L1 \n']);
0232 else
0233     fprintf(1, ['PASS: makelist, mode 3, L1 \n'])
0234     fprintf(fid, ['PASS: makelist, mode 3, L1 \n']);
0235 end
0236 
0237 % Mode 4
0238 rand('state', seed);
0239 mode4H1Test = makelist(N, 'testopt.txt', 'H1');
0240 rand('state', seed);
0241 mode4H2Test = makelist(N, 'testopt.txt', 'H2');
0242 rand('state', seed);
0243 mode4L1Test = makelist(N, 'testopt.txt', 'L1');
0244 
0245 if ~isequal(mode4H1,mode4H1Test)
0246     failCounter = failCounter+1;
0247     fprintf(1, ['FAIL: makelist, mode 4, H1 \n'])
0248     fprintf(fid, ['FAIL: makelist, mode 4, H1 \n']);
0249 else
0250     fprintf(1, ['PASS: makelist, mode 4, H1 \n'])
0251     fprintf(fid, ['PASS: makelist, mode 4, H1 \n']);
0252 end
0253 
0254 if ~isequal(mode4H2,mode4H2Test)
0255     failCounter = failCounter+1;
0256     fprintf(1, ['FAIL: makelist, mode 4, H2 \n'])
0257     fprintf(fid, ['FAIL: makelist, mode 4, H2 \n']);
0258 else
0259     fprintf(1, ['PASS: makelist, mode 4, H2 \n'])
0260     fprintf(fid, ['PASS: makelist, mode 4, H2 \n']);
0261 end
0262 
0263 if ~isequal(mode4L1,mode4L1Test)
0264     failCounter = failCounter+1;
0265     fprintf(1, ['FAIL: makelist, mode 4, L1 \n'])
0266     fprintf(fid, ['FAIL: makelist, mode 4, L1 \n']);
0267 else
0268     fprintf(1, ['PASS: makelist, mode 4, L1 \n'])
0269     fprintf(fid, ['PASS: makelist, mode 4, L1 \n']);
0270 end
0271 
0272 % Mode 5
0273 rand('state', seed);
0274 mode5aTest = makelist(N,simId,amplA,startSamp,'optimal','random');
0275 rand('state', seed);
0276 mode5bTest = makelist(N,simId,amplB,startSamp,internal,external);
0277 rand('state', seed);
0278 mode5cTest = makelist(N,simId,amplC,startSamp,Internal,External);
0279 
0280 if ~isequal(mode5a,mode5aTest)
0281     failCounter = failCounter+1;
0282     fprintf(1, ['FAIL: makelist, mode 5, ampl fixed, ' ...
0283             'internal=''optimal'', external=''random'' \n'])
0284     fprintf(fid, ['FAIL: makelist, mode 5, ampl fixed, ' ...
0285             'internal=''optimal'', external=''random'' \n']);
0286 else
0287     fprintf(1, ['PASS: makelist, mode 5, ampl fixed, ' ...
0288             'internal=''optimal'', external=''random'' \n'])
0289     fprintf(fid, ['PASS: makelist, mode 5, ampl fixed, ' ...
0290             'internal=''optimal'', external=''random'' \n']);
0291 end
0292 
0293 if ~isequal(mode5b,mode5bTest)
0294     failCounter = failCounter+1;   
0295     fprintf(1, ['FAIL: makelist, mode 5, ampl log dist., ' ...
0296             'internal double, external double \n'])
0297     fprintf(fid, ['FAIL: makelist, mode 5, ampl log dist., ' ...
0298             'internal double, external double \n']);
0299 else
0300     fprintf(1, ['PASS: makelist, mode 5, ampl log dist., ' ...
0301             'internal double, external double \n'])
0302     fprintf(fid, ['PASS: makelist, mode 5, ampl log dist., ' ...
0303             'internal double, external double \n']);
0304 end
0305 
0306 if ~isequal(mode5c,mode5cTest)
0307     failCounter = failCounter+1;
0308     fprintf(1, ['FAIL: makelist, mode 5, ampl lin. discrete, ' ...
0309             'internal struct, external struct \n'])
0310     fprintf(fid, ['FAIL: makelist, mode 5, ampl lin. discrete, ' ...
0311             'internal struct, external struct \n']);
0312 else
0313     fprintf(1, ['PASS: makelist, mode 5, ampl lin. discrete, ' ...
0314             'internal struct, external struct \n'])
0315     fprintf(fid, ['PASS: makelist, mode 5, ampl lin. discrete, ' ...
0316             'internal struct, external struct \n']);
0317 end
0318 
0319 % Mode 6
0320 rand('state', seed);
0321 mode6H1Test = makelist(N,simId,amplA,startSamp,'optimal','optimal','H1');
0322 rand('state', seed);
0323 mode6H2Test = makelist(N,simId,amplA,startSamp,'optimal','optimal','H2');
0324 rand('state', seed);
0325 mode6L1Test = makelist(N,simId,amplA,startSamp,'optimal','optimal','L1');
0326 
0327 if ~isequal(mode6H1,mode6H1Test)
0328     failCounter = failCounter+1;
0329     fprintf(1, ['FAIL: makelist, mode 6, H1 \n'])
0330     fprintf(fid, ['FAIL: makelist, mode 6, H1 \n']);
0331 else
0332     fprintf(1, ['PASS: makelist, mode 6, H1 \n'])
0333     fprintf(fid, ['PASS: makelist, mode 6, H1 \n']);
0334 end
0335 
0336 if ~isequal(mode6H2,mode6H2Test)
0337     failCounter = failCounter+1;
0338     fprintf(1, ['FAIL: makelist, mode 6, H2 \n'])
0339     fprintf(fid, ['FAIL: makelist, mode 6, H2 \n']);
0340 else
0341     fprintf(1, ['PASS: makelist, mode 6, H2 \n'])
0342     fprintf(fid, ['PASS: makelist, mode 6, H2 \n']);
0343 end
0344 
0345 if ~isequal(mode6L1,mode6L1Test)
0346     failCounter = failCounter+1;
0347     fprintf(1, ['FAIL: makelist, mode 6, L1 \n'])
0348     fprintf(fid, ['FAIL: makelist, mode 6, L1 \n']);
0349 else
0350     fprintf(1, ['PASS: makelist, mode 6, L1 \n'])
0351     fprintf(fid, ['PASS: makelist, mode 6, L1 \n']);
0352 end
0353 
0354 % getifo
0355 
0356 [errorH1, errorH2, errorL1] = testgetifo;
0357 
0358 if errorH1
0359     failCounter = failCounter+1;
0360     fprintf(1, 'FAIL: getifo, H1 \n')
0361     fprintf(fid, 'FAIL: getifo, H1 \n');
0362 else
0363     fprintf(1, 'PASS: getifo, H1 \n')
0364     fprintf(fid, 'PASS: getifo, H1 \n');
0365 end
0366 
0367 if errorH2
0368     failCounter = failCounter+1;
0369     fprintf(1, 'FAIL: getifo, H2 \n')
0370     fprintf(fid, 'FAIL: getifo, H2 \n');
0371 else
0372     fprintf(1, 'PASS: getifo, H2 \n')
0373     fprintf(fid, 'PASS: getifo, H2 \n');
0374 end
0375 
0376 if errorL1
0377     failCounter = failCounter+1;
0378     fprintf(1, 'FAIL: getifo, L1 \n')
0379     fprintf(fid, 'FAIL: getifo, L1 \n');
0380 else
0381     fprintf(1, 'PASS: getifo, L1 \n')
0382     fprintf(fid, 'PASS: getifo, L1 \n');
0383 end
0384 
0385 % ifodelay
0386 
0387 delayH1 = testifodelay('H1', 16384, 'off');
0388 delayH2 = testifodelay('H2', 16384, 'off');
0389 delayL1 = testifodelay('L1', 16384, 'off');
0390 
0391 difDelayLho1 = delayLHO-delayH1;
0392 difDelayLho2 = delayLHO-delayH2;
0393 difDelayLlo = delayLLO-delayL1;
0394 
0395 maxDifDelayLho1 = max(max(difDelayLho1));
0396 maxDifDelayLho2 = max(max(difDelayLho2));
0397 maxDifDelayLlo = max(max(difDelayLlo));
0398 
0399 if abs(maxDifDelayLho1) > TOLERANCE
0400     failCounter = failCounter+1;
0401     fprintf(1, 'FAIL: ifodelay, H1 \n')
0402     fprintf(fid, 'FAIL: ifodelay, H1 \n');
0403 else
0404     fprintf(1, 'PASS: ifodelay, H1 \n')
0405     fprintf(fid, 'PASS: ifodelay, H1 \n');
0406 end
0407 
0408 if abs(maxDifDelayLho2) > TOLERANCE
0409     failCounter = failCounter+1;
0410     fprintf(1, 'FAIL: ifodelay, H2 \n')
0411     fprintf(fid, 'FAIL: ifodelay, H2 \n');
0412 else
0413     fprintf(1, 'PASS: ifodelay, H2 \n')
0414     fprintf(fid, 'PASS: ifodelay, H2 \n');
0415 end
0416 
0417 if abs(maxDifDelayLlo) > TOLERANCE
0418     failCounter = failCounter+1;
0419     fprintf(1, 'FAIL: ifodelay, L1 \n')
0420     fprintf(fid, 'FAIL: ifodelay, L1 \n');
0421 else
0422     fprintf(1, 'PASS: ifodelay, L1 \n')
0423     fprintf(fid, 'PASS: ifodelay, L1 \n');
0424 end
0425 
0426 % simparse
0427 
0428 errorSimparse = testsimparse;
0429 
0430 if errorSimparse
0431     failCounter = failCounter+1;
0432     fprintf(1, 'FAIL: simparse \n')
0433     fprintf(fid, 'FAIL: simparse \n');
0434 else
0435     fprintf(1, 'PASS: simparse \n')
0436     fprintf(fid, 'PASS: simparse \n');
0437 end
0438 
0439 % makeh
0440 
0441 ampl = 1e-21;
0442 startSamp = 1;
0443 sampFreq = 16384;
0444 
0445 hijGTest = makeh(simIdG, ampl, startSamp, sampFreq);
0446 
0447 if ~isequal(hijGTest, hijG)
0448     failCounter = failCounter+1;
0449     fprintf(1, ['FAIL: makeh, ' simIdG '\n'])
0450     fprintf(fid, ['FAIL: makeh, ' simIdG '\n']);
0451 else
0452     fprintf(1, ['PASS: makeh, ' simIdG '\n'])
0453     fprintf(fid, ['PASS: makeh, ' simIdG '\n']);
0454 end
0455 
0456 hijSGTest = makeh(simIdSG, ampl, startSamp, sampFreq);
0457 
0458 if ~isequal(hijSGTest, hijSG)
0459     failCounter = failCounter+1;
0460     fprintf(1, ['FAIL: makeh, ' simIdSG '\n'])
0461     fprintf(fid, ['FAIL: makeh, ' simIdSG '\n']);
0462 else
0463     fprintf(1, ['PASS: makeh, ' simIdSG '\n'])
0464     fprintf(fid, ['PASS: makeh, ' simIdSG '\n']);
0465 end
0466 
0467 hijCGTest = makeh(simIdCG, ampl, startSamp, sampFreq);
0468 
0469 if ~isequal(hijCGTest, hijCG)
0470     failCounter = failCounter+1;
0471     fprintf(1, ['FAIL: makeh, ' simIdCG '\n'])
0472     fprintf(fid, ['FAIL: makeh, ' simIdCG '\n']);
0473 else
0474     fprintf(1, ['PASS: makeh, ' simIdCG '\n'])
0475     fprintf(fid, ['PASS: makeh, ' simIdCG '\n']);
0476 end
0477 
0478 hijBHTest = makeh(simIdBH, ampl, startSamp, sampFreq);
0479 
0480 if ~isequal(hijBHTest, hijBH)
0481     failCounter = failCounter+1;
0482     fprintf(1, ['FAIL: makeh, ' simIdBH '\n'])
0483     fprintf(fid, ['FAIL: makeh, ' simIdBH '\n']);
0484 else
0485     fprintf(1, ['PASS: makeh, ' simIdBH '\n'])
0486     fprintf(fid, ['PASS: makeh, ' simIdBH '\n']);
0487 end
0488 
0489 hijSINTest = makeh(simIdSIN, ampl, startSamp, sampFreq);
0490 
0491 if ~isequal(hijSINTest, hijSIN)
0492     failCounter = failCounter+1;
0493     fprintf(1, ['FAIL: makeh, ' simIdSIN '\n'])
0494     fprintf(fid, ['FAIL: makeh, ' simIdSIN '\n']);
0495 else
0496     fprintf(1, ['PASS: makeh, ' simIdSIN '\n'])
0497     fprintf(fid, ['PASS: makeh, ' simIdSIN '\n']);
0498 end
0499 
0500 hijCOSTest = makeh(simIdCOS, ampl, startSamp, sampFreq);
0501 
0502 if ~isequal(hijCOSTest, hijCOS)
0503     failCounter = failCounter+1;
0504     fprintf(1, ['FAIL: makeh, ' simIdCOS '\n'])
0505     fprintf(fid, ['FAIL: makeh, ' simIdCOS '\n']);
0506 else
0507     fprintf(1, ['PASS: makeh, ' simIdCOS '\n'])
0508     fprintf(fid, ['PASS: makeh, ' simIdCOS '\n']);
0509 end
0510 
0511 hijSINCTest = makeh(simIdSINC, ampl, startSamp, sampFreq);
0512 
0513 if ~isequal(hijSINCTest, hijSINC)
0514     failCounter = failCounter+1;
0515     fprintf(1, ['FAIL: makeh, ' simIdSINC '\n'])
0516     fprintf(fid, ['FAIL: makeh, ' simIdSINC '\n']);
0517 else
0518     fprintf(1, ['PASS: makeh, ' simIdSINC '\n'])
0519     fprintf(fid, ['PASS: makeh, ' simIdSINC '\n']);
0520 end
0521 
0522 hijCHIRPTest = makeh(simIdCHIRP, ampl, startSamp, sampFreq);
0523 
0524 if ~isequal(hijCHIRPTest, hijCHIRP)
0525     failCounter = failCounter+1;
0526     fprintf(1, ['FAIL: makeh, ' simIdCHIRP '\n'])
0527     fprintf(fid, ['FAIL: makeh, ' simIdCHIRP '\n']);
0528 else
0529     fprintf(1, ['PASS: makeh, ' simIdCHIRP '\n'])
0530     fprintf(fid, ['PASS: makeh, ' simIdCHIRP '\n']);
0531 end
0532 
0533 hijSQUARETest = makeh(simIdSQUARE, ampl, startSamp, sampFreq);
0534 
0535 if ~isequal(hijSQUARETest, hijSQUARE)
0536     failCounter = failCounter+1;
0537     fprintf(1, ['FAIL: makeh, ' simIdSQUARE '\n'])
0538     fprintf(fid, ['FAIL: makeh, ' simIdSQUARE '\n']);
0539 else
0540     fprintf(1, ['PASS: makeh, ' simIdSQUARE '\n'])
0541     fprintf(fid, ['PASS: makeh, ' simIdSQUARE '\n']);
0542 end
0543 
0544 hijSQUAREGTest = makeh(simIdSQUAREG, ampl, startSamp, sampFreq);
0545 
0546 if ~isequal(hijSQUAREGTest, hijSQUAREG)
0547     failCounter = failCounter+1;
0548     fprintf(1, ['FAIL: makeh, ' simIdSQUAREG '\n'])
0549     fprintf(fid, ['FAIL: makeh, ' simIdSQUAREG '\n']);
0550 else
0551     fprintf(1, ['PASS: makeh, ' simIdSQUAREG '\n'])
0552     fprintf(fid, ['PASS: makeh, ' simIdSQUAREG '\n']);
0553 end
0554 
0555 hijSAWTOOTHTest = makeh(simIdSAWTOOTH, ampl, startSamp, sampFreq);
0556 
0557 if ~isequal(hijSAWTOOTHTest, hijSAWTOOTH)
0558     failCounter = failCounter+1;
0559     fprintf(1, ['FAIL: makeh, ' simIdSAWTOOTH '\n'])
0560     fprintf(fid, ['FAIL: makeh, ' simIdSAWTOOTH '\n']);
0561 else
0562     fprintf(1, ['PASS: makeh, ' simIdSAWTOOTH '\n'])
0563     fprintf(fid, ['PASS: makeh, ' simIdSAWTOOTH '\n']);
0564 end
0565 
0566 hijSAWTOOTHGTest = makeh(simIdSAWTOOTHG, ampl, startSamp, sampFreq);
0567 
0568 if ~isequal(hijSAWTOOTHGTest, hijSAWTOOTHG)
0569     failCounter = failCounter+1;
0570     fprintf(1, ['FAIL: makeh, ' simIdSAWTOOTHG '\n'])
0571     fprintf(fid, ['FAIL: makeh, ' simIdSAWTOOTHG '\n']);
0572 else
0573     fprintf(1, ['PASS: makeh, ' simIdSAWTOOTHG '\n'])
0574     fprintf(fid, ['PASS: makeh, ' simIdSAWTOOTHG '\n']);
0575 end
0576 
0577 % makett
0578 
0579 errorMakeTt = testmakett;
0580 
0581 if errorMakeTt
0582     failCounter = failCounter+1;
0583     fprintf(1, 'FAIL: makett \n')
0584     fprintf(fid, 'FAIL: makett \n');
0585 else
0586     fprintf(1, 'PASS: makett \n')
0587     fprintf(fid, 'PASS: makett \n');
0588 end
0589 
0590 % detproj
0591 
0592 antennaH1 = testdetproj('H1', 'off');
0593 antennaH2 = testdetproj('H2', 'off');
0594 antennaL1 = testdetproj('L1', 'off');
0595 
0596 difAntennaH1 = antennaLHO-antennaH1;
0597 difAntennaH2 = antennaLHO-antennaH2;
0598 difAntennaL1 = antennaLLO-antennaL1;
0599 
0600 maxDifAntennaH1 = max(max(difAntennaH1));
0601 maxDifAntennaH2 = max(max(difAntennaH2));
0602 maxDifAntennaL1 = max(max(difAntennaL1));
0603 
0604 if abs(maxDifAntennaH1) > TOLERANCE
0605     failCounter = failCounter+1;
0606     fprintf(1, 'FAIL: detproj, H1 \n')
0607     fprintf(fid, 'FAIL: detproj, H1 \n');
0608 else
0609     fprintf(1, 'PASS: detproj, H1 \n')
0610     fprintf(fid, 'PASS: detproj, H1 \n');
0611 end
0612 
0613 if abs(maxDifAntennaH2) > TOLERANCE
0614     failCounter = failCounter+1;
0615     fprintf(1, 'FAIL: detproj, H2 \n')
0616     fprintf(fid, 'FAIL: detproj, H2 \n');
0617 else
0618     fprintf(1, 'PASS: detproj, H2 \n')
0619     fprintf(fid, 'PASS: detproj, H2 \n');
0620 end
0621 
0622 if abs(maxDifAntennaL1) > TOLERANCE
0623     failCounter = failCounter+1;
0624     fprintf(1, 'FAIL: detproj, L1 \n')
0625     fprintf(fid, 'FAIL: detproj, L1 \n');
0626 else
0627     fprintf(1, 'PASS: detproj, L1 \n')
0628     fprintf(fid, 'PASS: detproj, L1 \n');
0629 end
0630 
0631 if failCounter == 0
0632     fprintf(1, ['# GravEn build test ran successfully without error! '...
0633             '\n# +++ \n'])
0634     fprintf(fid, ['# GravEn build test ran successfully without ' ...
0635             'error! \n# +++ \n']);
0636     gravenPass = true;
0637 else 
0638     nFails = num2str(failCounter);
0639     fprintf(1, ['# GravEn build test encountered ' nFails ' error(s). ' ...
0640             '\n# --- \n'])
0641     fprintf(fid, ['# GravEn build test encountered ' nFails ' ' ...
0642             'error(s). \n# --- \n']);
0643     gravenPass = ~true;
0644 end
0645 
0646 fclose(fid);
0647 
0648 return