Loading...
Searching...
No Matches
TestGAMSOptions.cs
1using System;
2using System.Collections.Generic;
3using System.IO;
4using System.Linq;
5using GAMS;
6using NLog;
7using NUnit.Framework;
8
9namespace GamsApiTests
10{
11 [TestFixture]
13 {
14
15 static readonly String PROPERTIES_FILE = "test.properties";
16 static String workingDir;
17 static GAMSWorkspaceInfo wsInfo = null;
18 static GAMSWorkspace ws = null;
19 static GAMSDatabase db = null;
20 static GAMSWorkspace globalWS;
21 static GAMSOptions globalOpt;
22 static Logger logger = LogManager.GetCurrentClassLogger();
23
24 [OneTimeSetUp]
25 public static void OneTimeSetup()
26 {
27 logger.Debug("TestGAMSOptions | OneTimeSetup");
28 workingDir = HouseKeeper.gamsAbsoluteWorkingDir;
29 HouseKeeper.initializeTestFrom(PROPERTIES_FILE, "TestGAMSOptions");
30 logger.Debug("TestGAMSOptions | oneTimeSetup");
31
33 wsInfo.WorkingDirectory = (HouseKeeper.gamsWorkingDir);
34 wsInfo.SystemDirectory = (HouseKeeper.gamsSystemDir);
35 wsInfo.Debug = DebugLevel.Off;
36 globalWS = new GAMSWorkspace(wsInfo);
37 globalOpt = globalWS.AddOptions();
38
39 }
40
41 [OneTimeTearDown]
42 public static void OneTimeTearDown()
43 {
44 if (globalOpt != null)
45 globalOpt.Dispose();
46 File.Delete(HouseKeeper.gamsWorkingDir);
47 }
48
49 [Test]
50 public void TestEnumAction()
51 {
52 logger.Debug("Entering TestGAMSOptions | testEnumAction");
53
54 globalOpt.Action = GAMSOptions.EAction.RestartAfterSolve;
55 Assert.AreEqual(GAMSOptions.EAction.RestartAfterSolve, globalOpt.Action, "expect same options " + GAMSOptions.EAction.RestartAfterSolve + " set");
56
57 globalOpt.Action = GAMSOptions.EAction.CompileOnly;
58 Assert.AreEqual(GAMSOptions.EAction.CompileOnly, globalOpt.Action, "expect same options " + GAMSOptions.EAction.CompileOnly + " set");
59
60 globalOpt.Action = GAMSOptions.EAction.ExecuteOnly;
61 Assert.AreEqual(GAMSOptions.EAction.ExecuteOnly, globalOpt.Action, "expect same options " + GAMSOptions.EAction.ExecuteOnly + " set");
62
63 globalOpt.Action = GAMSOptions.EAction.CompileAndExecute;
64 Assert.AreEqual(GAMSOptions.EAction.CompileAndExecute, globalOpt.Action, "expect same options " + GAMSOptions.EAction.CompileAndExecute + " set");
65
66 globalOpt.Action = GAMSOptions.EAction.GlueCodeGeneration;
67 Assert.AreEqual(GAMSOptions.EAction.GlueCodeGeneration, globalOpt.Action, "expect same options " + GAMSOptions.EAction.GlueCodeGeneration + " set");
68
69 globalOpt.Action = GAMSOptions.EAction.TraceReport;
70 Assert.AreEqual(GAMSOptions.EAction.TraceReport, globalOpt.Action, "expect same options " + GAMSOptions.EAction.TraceReport + " set");
71
72 logger.Debug("Exiting TestGAMSOptions | testEnumAction");
73 }
74
75
77 //[Test]
78 //public void TestLookupEnumAction()
79 //{
80 // logger.Debug("Entering TestGAMSOptions | testLookupEnumAction");
81
82 // Assert.AreEqual("Lookup R from EAction", GAMSOptions.EAction.RestartAfterSolve, GAMSOptions.EAction.lookup("R"));
83 // Assert.AreEqual("Lookup C from EAction", GAMSOptions.EAction.CompileOnly, GAMSOptions.EAction.lookup("C"));
84 // Assert.AreEqual("Lookup E from EAction", GAMSOptions.EAction.ExecuteOnly, GAMSOptions.EAction.lookup("E"));
85 // Assert.AreEqual("Lookup CE from EAction", GAMSOptions.EAction.CompileAndExecute, GAMSOptions.EAction.lookup("CE"));
86 // Assert.AreEqual("Lookup G from EAction", GAMSOptions.EAction.GlueCodeGeneration, GAMSOptions.EAction.lookup("G"));
87 // Assert.AreEqual("Lookup GT from EAction", GAMSOptions.EAction.TraceReport, GAMSOptions.EAction.lookup("GT"));
88
89 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumAction");
90 //}
91
92 [Test]
93 public void TestEnumAppendExpand()
94 {
95 logger.Debug("Entering TestGAMSOptions | testEnumAppendExpand");
96
97 globalOpt.AppendExpand = (GAMSOptions.EAppendExpand.Reset);
98 Assert.AreEqual(GAMSOptions.EAppendExpand.Reset, globalOpt.AppendExpand, "expect same options " + GAMSOptions.EAppendExpand.Reset + " set");
99
100 globalOpt.AppendExpand = (GAMSOptions.EAppendExpand.Append);
101 Assert.AreEqual(GAMSOptions.EAppendExpand.Append, globalOpt.AppendExpand, "expect same options " + GAMSOptions.EAppendExpand.Append + " set");
102
103 logger.Debug("Exiting TestGAMSOptions | testEnumAppendExpand");
104 }
105
106 //[Test]
107 //public void TestLookupEnumAppendExpand()
108 //{
109 // logger.Debug("Entering TestGAMSOptions | testLookupEnumAppendExpand");
110
111 // Assert.AreEqual("Lookup Reset from EAppendExpand", GAMSOptions.EAppendExpand.Reset, GAMSOptions.EAppendExpand.lookup(0));
112 // Assert.AreEqual("Lookup Append from EAppendExpand", GAMSOptions.EAppendExpand.Append, GAMSOptions.EAppendExpand.lookup(1));
113
114 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumAppendExpand");
115 //}
116
117
118 [Test]
119 public void TestEnumAppendOut()
120 {
121 logger.Debug("Entering TestGAMSOptions | testEnumAppendOut");
122
123 globalOpt.AppendOut = (GAMSOptions.EAppendOut.Reset);
124 Assert.AreEqual(GAMSOptions.EAppendOut.Reset, globalOpt.AppendOut, "expect same options " + GAMSOptions.EAppendOut.Reset + " set");
125
126 globalOpt.AppendOut = (GAMSOptions.EAppendOut.Append);
127 Assert.AreEqual(GAMSOptions.EAppendOut.Append, globalOpt.AppendOut, "expect same options " + GAMSOptions.EAppendOut.Append + " set");
128
129 logger.Debug("Exiting TestGAMSOptions | testEnumAppendOut");
130 }
131
132 //[Test]
133 //public void TestLookupEnumAppendOut()
134 //{
135 // logger.Debug("Entering TestGAMSOptions | testLookupEnumAppendOut");
136
137 // Assert.AreEqual("Lookup Reset from EAppendOut", GAMSOptions.EAppendOut.Reset, GAMSOptions.EAppendOut.lookup(0));
138 // Assert.AreEqual("Lookup Append from EAppendOut", GAMSOptions.EAppendOut.Append, GAMSOptions.EAppendOut.lookup(1));
139
140 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumAppendOut");
141 //}
142
143
144 [Test]
145 public void TestEnumAsyncSolLst()
146 {
147 logger.Debug("Entering TestGAMSOptions | testEnumAsyncSolLst");
148
149 globalOpt.AsyncSolLst = (GAMSOptions.EAsyncSolLst.Off);
150 Assert.AreEqual(GAMSOptions.EAsyncSolLst.Off, globalOpt.AsyncSolLst, "expect same options " + GAMSOptions.EAsyncSolLst.Off + " set");
151
152 globalOpt.AsyncSolLst = (GAMSOptions.EAsyncSolLst.On);
153 Assert.AreEqual(GAMSOptions.EAsyncSolLst.On, globalOpt.AsyncSolLst, "expect same options " + GAMSOptions.EAsyncSolLst.On + " set");
154
155 logger.Debug("Exiting TestGAMSOptions | testEnumAsyncSolLst");
156 }
157
158 //[Test]
159 //public void TestLookupEnumAsyncSolLst()
160 //{
161 // logger.Debug("Entering TestGAMSOptions | testLookupEnumAsyncSolLst");
162
163 // Assert.AreEqual("Lookup Off from EAsyncSolLst", GAMSOptions.EAsyncSolLst.Off, GAMSOptions.EAsyncSolLst.lookup(0));
164 // Assert.AreEqual("Lookup On from EAsyncSolLst", GAMSOptions.EAsyncSolLst.On, GAMSOptions.EAsyncSolLst.lookup(1));
165
166 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumAsyncSolLst");
167 //}
168
169
170 [Test]
171 public void TestEnumCaptureModelInstance()
172 {
173 logger.Debug("Entering TestGAMSOptions | testEnumCaptureModelInstance");
174
175 globalOpt.CaptureModelInstance = (GAMSOptions.ECaptureModelInstance.Off);
176 Assert.AreEqual(GAMSOptions.ECaptureModelInstance.Off, globalOpt.CaptureModelInstance, "expect same options " + GAMSOptions.ECaptureModelInstance.Off + " set");
177
178 globalOpt.CaptureModelInstance = (GAMSOptions.ECaptureModelInstance.On);
179 Assert.AreEqual(GAMSOptions.ECaptureModelInstance.On, globalOpt.CaptureModelInstance, "expect same options " + GAMSOptions.ECaptureModelInstance.On + " set");
180
181 logger.Debug("Exiting TestGAMSOptions | testEnumCaptureModelInstance");
182 }
183
184 //[Test]
185 //public void TestLookupEnumCaptureModelInstance()
186 //{
187 // logger.Debug("Entering TestGAMSOptions | testLookupEnumCaptureModelInstance");
188
189 // Assert.AreEqual("Lookup Off from ECaptureModelInstance", GAMSOptions.ECaptureModelInstance.Off, GAMSOptions.ECaptureModelInstance.lookup(0));
190 // Assert.AreEqual("Lookup On from ECaptureModelInstance", GAMSOptions.ECaptureModelInstance.On, GAMSOptions.ECaptureModelInstance.lookup(1));
191
192 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumCaptureModelInstance");
193 //}
194
195
196 [Test]
197 public void TestEnumCase()
198 {
199 logger.Debug("Entering TestGAMSOptions | testEnumCase");
200
201 globalOpt.Case = (GAMSOptions.ECase.MixedCase);
202 Assert.AreEqual(GAMSOptions.ECase.MixedCase, globalOpt.Case, "expect same options " + GAMSOptions.ECase.MixedCase + " set");
203
204 globalOpt.Case = (GAMSOptions.ECase.UpperCase);
205 Assert.AreEqual(GAMSOptions.ECase.UpperCase, globalOpt.Case, "expect same options " + GAMSOptions.ECase.UpperCase + " set");
206
207 logger.Debug("Exiting TestGAMSOptions | testEnumCase");
208 }
209
210 //[Test]
211 //public void TestLookupEnumCase()
212 //{
213 // logger.Debug("Entering TestGAMSOptions | testLookupEnumCase");
214
215 // Assert.AreEqual("Lookup MixedCase from ECase", GAMSOptions.ECase.MixedCase, GAMSOptions.ECase.lookup(0));
216 // Assert.AreEqual("Lookup UpperCase from ECase", GAMSOptions.ECase.UpperCase, GAMSOptions.ECase.lookup(1));
217
218 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumCase");
219 //}
220
221
222 [Test]
223 public void TestEnumCharSet()
224 {
225 logger.Debug("Entering TestGAMSOptions | testEnumCharSet");
226
227 globalOpt.CharSet = (GAMSOptions.ECharSet.LimitedGAMSCharSet);
228 Assert.AreEqual(GAMSOptions.ECharSet.LimitedGAMSCharSet, globalOpt.CharSet, "expect same options " + GAMSOptions.ECharSet.LimitedGAMSCharSet + " set");
229
230 globalOpt.CharSet = (GAMSOptions.ECharSet.AnyChar);
231 Assert.AreEqual(GAMSOptions.ECharSet.AnyChar, globalOpt.CharSet, "expect same options " + GAMSOptions.ECharSet.AnyChar + " set");
232
233 logger.Debug("Exiting TestGAMSOptions | testEnumCharSet");
234 }
235
236 //[Test]
237 //public void TestLookupEnumCharSet()
238 //{
239 // logger.Debug("Entering TestGAMSOptions | testLookupEnumCharSet");
240
241 // Assert.AreEqual("Lookup LimitedGAMSCharSet from ECharSet", GAMSOptions.ECharSet.LimitedGAMSCharSet, GAMSOptions.ECharSet.lookup(0));
242 // Assert.AreEqual("Lookup AnyChar from ECharSet", GAMSOptions.ECharSet.AnyChar, GAMSOptions.ECharSet.lookup(1));
243
244 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumCharSet");
245 //}
246
247
248 [Test]
249 public void TestEnumCheckErrorLevel()
250 {
251 logger.Debug("Entering TestGAMSOptions | testEnumCheckErrorLevel");
252
253 globalOpt.CheckErrorLevel = (GAMSOptions.ECheckErrorLevel.Off);
254 Assert.AreEqual(GAMSOptions.ECheckErrorLevel.Off, globalOpt.CheckErrorLevel, "expect same options " + GAMSOptions.ECheckErrorLevel.Off + " set");
255
256 globalOpt.CheckErrorLevel = (GAMSOptions.ECheckErrorLevel.On);
257 Assert.AreEqual(GAMSOptions.ECheckErrorLevel.On, globalOpt.CheckErrorLevel, "expect same options " + GAMSOptions.ECheckErrorLevel.On + " set");
258
259 logger.Debug("Exiting TestGAMSOptions | testEnumCheckErrorLevel");
260 }
261
262 //[Test]
263 //public void TestLookupEnumCheckErrorLevel()
264 //{
265 // logger.Debug("Entering TestGAMSOptions | testLookupEnumCheckErrorLevel");
266
267 // Assert.AreEqual("Lookup Off from ECheckErrorLevel", GAMSOptions.ECheckErrorLevel.Off, GAMSOptions.ECheckErrorLevel.lookup(0));
268 // Assert.AreEqual("Lookup On from ECheckErrorLevel", GAMSOptions.ECheckErrorLevel.On, GAMSOptions.ECheckErrorLevel.lookup(1));
269
270 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumCheckErrorLevel");
271 //}
272
273
274 [Test]
275 public void TestEnumDFormat()
276 {
277 logger.Debug("Entering TestGAMSOptions | testEnumDFormat");
278
279 globalOpt.DFormat = (GAMSOptions.EDFormat.Slash);
280 Assert.AreEqual(GAMSOptions.EDFormat.Slash, globalOpt.DFormat, "expect same options " + GAMSOptions.EDFormat.Slash + " set");
281
282 globalOpt.DFormat = (GAMSOptions.EDFormat.Dot);
283 Assert.AreEqual(GAMSOptions.EDFormat.Dot, globalOpt.DFormat, "expect same options " + GAMSOptions.EDFormat.Dot + " set");
284
285 globalOpt.DFormat = (GAMSOptions.EDFormat.Dash);
286 Assert.AreEqual(GAMSOptions.EDFormat.Dash, globalOpt.DFormat, "expect same options " + GAMSOptions.EDFormat.Dash + " set");
287
288 logger.Debug("Exiting TestGAMSOptions | testEnumDFormat");
289 }
290
291 //[Test]
292 //public void TestLookupEnumDFormat()
293 //{
294 // logger.Debug("Entering TestGAMSOptions | testLookupEnumDFormat");
295
296 // Assert.AreEqual("Lookup Slash from EDFormat", GAMSOptions.EDFormat.Slash, GAMSOptions.EDFormat.lookup(0));
297 // Assert.AreEqual("Lookup Dot from EDFormat", GAMSOptions.EDFormat.Dot, GAMSOptions.EDFormat.lookup(1));
298 // Assert.AreEqual("Lookup Dash from EDFormat", GAMSOptions.EDFormat.Dash, GAMSOptions.EDFormat.lookup(2));
299
300 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumDFormat");
301 //}
302
303
304 [Test]
305 public void TestEnumDigit()
306 {
307 logger.Debug("Entering TestGAMSOptions | testEnumDigit");
308
309 globalOpt.Digit = (GAMSOptions.EDigit.OffDigit);
310 Assert.AreEqual(GAMSOptions.EDigit.OffDigit, globalOpt.Digit, "expect same options " + GAMSOptions.EDigit.OffDigit + " set");
311
312 globalOpt.Digit = (GAMSOptions.EDigit.OnDigit);
313 Assert.AreEqual(GAMSOptions.EDigit.OnDigit, globalOpt.Digit, "expect same options " + GAMSOptions.EDigit.OnDigit + " set");
314
315 logger.Debug("Exiting TestGAMSOptions | testEnumDigit");
316 }
317
318 //[Test]
319 //public void TestLookupEnumDigit()
320 //{
321 // logger.Debug("Entering TestGAMSOptions | testLookupEnumDigit");
322
323 // Assert.AreEqual("Lookup off from EDigit", GAMSOptions.EDigit.OffDigit, GAMSOptions.EDigit.lookup("off"));
324 // Assert.AreEqual("Lookup on from EDigit", GAMSOptions.EDigit.OnDigit, GAMSOptions.EDigit.lookup("on"));
325
326 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumDigit");
327 //}
328
329
330 [Test]
331 public void TestEnumDumpOpt()
332 {
333 logger.Debug("Entering TestGAMSOptions | testEnumDumpOpt");
334
335 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.No);
336 Assert.AreEqual(GAMSOptions.EDumpOpt.No, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.No + " set");
337
338 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.RefDataOriginalSetElementNames);
339 Assert.AreEqual(GAMSOptions.EDumpOpt.RefDataOriginalSetElementNames, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.RefDataOriginalSetElementNames + " set");
340
341 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.RefDataNewSetElementNames);
342 Assert.AreEqual(GAMSOptions.EDumpOpt.RefDataNewSetElementNames, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.RefDataNewSetElementNames + " set");
343
344 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.RefDataNewSetElementNamesDropSymbolText);
345 Assert.AreEqual(GAMSOptions.EDumpOpt.RefDataNewSetElementNamesDropSymbolText, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.RefDataNewSetElementNamesDropSymbolText + " set");
346
347 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.RefSymbol);
348 Assert.AreEqual(GAMSOptions.EDumpOpt.RefSymbol, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.RefSymbol + " set");
349
350 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.Deprecated_10);
351 Assert.AreEqual(GAMSOptions.EDumpOpt.Deprecated_10, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.Deprecated_10 + " set");
352
353 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.InputFileWOComments);
354 Assert.AreEqual(GAMSOptions.EDumpOpt.InputFileWOComments, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.InputFileWOComments + " set");
355
356 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.Deprecated_12);
357 Assert.AreEqual(GAMSOptions.EDumpOpt.Deprecated_12, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.Deprecated_12 + " set");
358
359 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.Deprecated_19);
360 Assert.AreEqual(GAMSOptions.EDumpOpt.Deprecated_19, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.Deprecated_19 + " set");
361
362 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.Deprecated_20);
363 Assert.AreEqual(GAMSOptions.EDumpOpt.Deprecated_20, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.Deprecated_20 + " set");
364
365 globalOpt.DumpOpt = (GAMSOptions.EDumpOpt.InputFileWithComments);
366 Assert.AreEqual(GAMSOptions.EDumpOpt.InputFileWithComments, globalOpt.DumpOpt, "expect same options " + GAMSOptions.EDumpOpt.InputFileWithComments + " set");
367
368 logger.Debug("Exiting TestGAMSOptions | testEnumDumpOpt");
369 }
370
371 //[Test]
372 //public void TestLookupEnumDumpOpt()
373 //{
374 // logger.Debug("Entering TestGAMSOptions | testLookupEnumDumpOpt");
375
376 // Assert.AreEqual("Lookup No from EDumpOpt", GAMSOptions.EDumpOpt.No, GAMSOptions.EDumpOpt.lookup(0));
377 // Assert.AreEqual("Lookup RefDataOriginalSetElementNames from EDumpOpt", GAMSOptions.EDumpOpt.RefDataOriginalSetElementNames, GAMSOptions.EDumpOpt.lookup(1));
378 // Assert.AreEqual("Lookup RefDataNewSetElementNames from EDumpOpt", GAMSOptions.EDumpOpt.RefDataNewSetElementNames, GAMSOptions.EDumpOpt.lookup(2));
379 // Assert.AreEqual("Lookup RefDataNewSetElementNamesDropSymbolText from EDumpOpt", GAMSOptions.EDumpOpt.RefDataNewSetElementNamesDropSymbolText, GAMSOptions.EDumpOpt.lookup(3));
380 // Assert.AreEqual("Lookup RefSymbol from EDumpOpt", GAMSOptions.EDumpOpt.RefSymbol, GAMSOptions.EDumpOpt.lookup(4));
381 // Assert.AreEqual("Lookup Deprecated_10 from EDumpOpt", GAMSOptions.EDumpOpt.Deprecated_10, GAMSOptions.EDumpOpt.lookup(10));
382 // Assert.AreEqual("Lookup InputFileWOComments from EDumpOpt", GAMSOptions.EDumpOpt.InputFileWOComments, GAMSOptions.EDumpOpt.lookup(11));
383 // Assert.AreEqual("Lookup Deprecated_12 from EDumpOpt", GAMSOptions.EDumpOpt.Deprecated_12, GAMSOptions.EDumpOpt.lookup(12));
384 // Assert.AreEqual("Lookup Deprecated_19 from EDumpOpt", GAMSOptions.EDumpOpt.Deprecated_19, GAMSOptions.EDumpOpt.lookup(19));
385 // Assert.AreEqual("Lookup Deprecated_20 from EDumpOpt", GAMSOptions.EDumpOpt.Deprecated_20, GAMSOptions.EDumpOpt.lookup(20));
386 // Assert.AreEqual("Lookup InputFileWithComments from EDumpOpt", GAMSOptions.EDumpOpt.InputFileWithComments, GAMSOptions.EDumpOpt.lookup(21));
387
388 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumDumpOpt");
389 //}
390
391
392 [Test]
393 public void TestEnumDumpParms()
394 {
395 logger.Debug("Entering TestGAMSOptions | testEnumDumpParms");
396
397 globalOpt.DumpParms = (GAMSOptions.EDumpParms.No);
398 Assert.AreEqual(GAMSOptions.EDumpParms.No, globalOpt.DumpParms, "expect same options " + GAMSOptions.EDumpParms.No + " set");
399
400 globalOpt.DumpParms = (GAMSOptions.EDumpParms.AcceptedParameters);
401 Assert.AreEqual(GAMSOptions.EDumpParms.AcceptedParameters, globalOpt.DumpParms, "expect same options " + GAMSOptions.EDumpParms.AcceptedParameters + " set");
402
403 globalOpt.DumpParms = (GAMSOptions.EDumpParms.FileOperationsAcceptedParameters);
404 Assert.AreEqual(GAMSOptions.EDumpParms.FileOperationsAcceptedParameters, globalOpt.DumpParms, "expect same options " + GAMSOptions.EDumpParms.FileOperationsAcceptedParameters + " set");
405
406 logger.Debug("Exiting TestGAMSOptions | testEnumDumpParms");
407 }
408
409 //[Test]
410 //public void TestLookupEnumDumpParms()
411 //{
412 // logger.Debug("Entering TestGAMSOptions | testLookupEnumDumpParms");
413
414 // Assert.AreEqual("Lookup No from EDumpParms", GAMSOptions.EDumpParms.No, GAMSOptions.EDumpParms.lookup(0));
415 // Assert.AreEqual("Lookup AcceptedParameters from EDumpParms", GAMSOptions.EDumpParms.AcceptedParameters, GAMSOptions.EDumpParms.lookup(1));
416 // Assert.AreEqual("Lookup FileOperationsAcceptedParameters from EDumpParms", GAMSOptions.EDumpParms.FileOperationsAcceptedParameters, GAMSOptions.EDumpParms.lookup(2));
417
418 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumDumpParms");
419 //}
420
421
422 [Test]
423 public void TestEnumECImplicitLoad()
424 {
425 logger.Debug("Entering TestGAMSOptions | testEnumECImplicitLoad");
426
427 globalOpt.ECImplicitLoad = (GAMSOptions.EECImplicitLoad.OffECImplicitLoad);
428 Assert.AreEqual(GAMSOptions.EECImplicitLoad.OffECImplicitLoad, globalOpt.ECImplicitLoad, "expect same options " + GAMSOptions.EECImplicitLoad.OffECImplicitLoad + " set");
429
430 globalOpt.ECImplicitLoad = (GAMSOptions.EECImplicitLoad.OnECImplicitLoad);
431 Assert.AreEqual(GAMSOptions.EECImplicitLoad.OnECImplicitLoad, globalOpt.ECImplicitLoad, "expect same options " + GAMSOptions.EECImplicitLoad.OnECImplicitLoad + " set");
432
433 logger.Debug("Exiting TestGAMSOptions | testEnumECImplicitLoad");
434 }
435
436 //[Test]
437 //public void TestLookupEnumECImplicitLoad()
438 //{
439 // logger.Debug("Entering TestGAMSOptions | testLookupEnumECImplicitLoad");
440
441 // Assert.AreEqual("Lookup off from EECImplicitLoad", GAMSOptions.EECImplicitLoad.OffECImplicitLoad, GAMSOptions.EECImplicitLoad.lookup("off"));
442 // Assert.AreEqual("Lookup on from EECImplicitLoad", GAMSOptions.EECImplicitLoad.OnECImplicitLoad, GAMSOptions.EECImplicitLoad.lookup("on"));
443
444 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumECImplicitLoad");
445 //}
446
447
448 [Test]
449 public void TestEnumEmpty()
450 {
451 logger.Debug("Entering TestGAMSOptions | testEnumEmpty");
452
453 globalOpt.Empty = (GAMSOptions.EEmpty.OffEmpty);
454 Assert.AreEqual(GAMSOptions.EEmpty.OffEmpty, globalOpt.Empty, "expect same options " + GAMSOptions.EEmpty.OffEmpty + " set");
455
456 globalOpt.Empty = (GAMSOptions.EEmpty.OnEmpty);
457 Assert.AreEqual(GAMSOptions.EEmpty.OnEmpty, globalOpt.Empty, "expect same options " + GAMSOptions.EEmpty.OnEmpty + " set");
458
459 logger.Debug("Exiting TestGAMSOptions | testEnumEmpty");
460 }
461
462 //[Test]
463 //public void TestLookupEnumEmpty()
464 //{
465 // logger.Debug("Entering TestGAMSOptions | testLookupEnumEmpty");
466
467 // Assert.AreEqual("Lookup off from EEmpty", GAMSOptions.EEmpty.OffEmpty, GAMSOptions.EEmpty.lookup("off"));
468 // Assert.AreEqual("Lookup on from EEmpty", GAMSOptions.EEmpty.OnEmpty, GAMSOptions.EEmpty.lookup("on"));
469
470 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumEmpty");
471 //}
472
473
474 [Test]
475 public void TestEnumErrMsg()
476 {
477 logger.Debug("Entering TestGAMSOptions | testEnumErrMsg");
478
479 globalOpt.ErrMsg = (GAMSOptions.EErrMsg.EndOfCompilerListing);
480 Assert.AreEqual(GAMSOptions.EErrMsg.EndOfCompilerListing, globalOpt.ErrMsg, "expect same options " + GAMSOptions.EErrMsg.EndOfCompilerListing + " set");
481
482 globalOpt.ErrMsg = (GAMSOptions.EErrMsg.FollowingError);
483 Assert.AreEqual(GAMSOptions.EErrMsg.FollowingError, globalOpt.ErrMsg, "expect same options " + GAMSOptions.EErrMsg.FollowingError + " set");
484
485 globalOpt.ErrMsg = (GAMSOptions.EErrMsg.Suppress);
486 Assert.AreEqual(GAMSOptions.EErrMsg.Suppress, globalOpt.ErrMsg, "expect same options " + GAMSOptions.EErrMsg.Suppress + " set");
487
488 logger.Debug("Exiting TestGAMSOptions | testEnumErrMsg");
489 }
490
491 //[Test]
492 //public void TestLookupEnumErrMsg()
493 //{
494 // logger.Debug("Entering TestGAMSOptions | testLookupEnumErrMsg");
495
496 // Assert.AreEqual("Lookup EndOfCompilerListing from EErrMsg", GAMSOptions.EErrMsg.EndOfCompilerListing, GAMSOptions.EErrMsg.lookup(0));
497 // Assert.AreEqual("Lookup FollowingError from EErrMsg", GAMSOptions.EErrMsg.FollowingError, GAMSOptions.EErrMsg.lookup(1));
498 // Assert.AreEqual("Lookup Suppress from EErrMsg", GAMSOptions.EErrMsg.Suppress, GAMSOptions.EErrMsg.lookup(2));
499
500 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumErrMsg");
501 //}
502
503
504 [Test]
505 public void TestEnumExecMode()
506 {
507 logger.Debug("Entering TestGAMSOptions | testEnumExecMode");
508
509 globalOpt.ExecMode = (GAMSOptions.EExecMode.EverythingAllowed);
510 Assert.AreEqual(GAMSOptions.EExecMode.EverythingAllowed, globalOpt.ExecMode, "expect same options " + GAMSOptions.EExecMode.EverythingAllowed + " set");
511
512 globalOpt.ExecMode = (GAMSOptions.EExecMode.InteractiveShellsProhibited);
513 Assert.AreEqual(GAMSOptions.EExecMode.InteractiveShellsProhibited, globalOpt.ExecMode, "expect same options " + GAMSOptions.EExecMode.InteractiveShellsProhibited + " set");
514
515 globalOpt.ExecMode = (GAMSOptions.EExecMode.CallAndExecuteProhibited);
516 Assert.AreEqual(GAMSOptions.EExecMode.CallAndExecuteProhibited, globalOpt.ExecMode, "expect same options " + GAMSOptions.EExecMode.CallAndExecuteProhibited + " set");
517
518 globalOpt.ExecMode = (GAMSOptions.EExecMode.EchoAndPutOnlyToWorkdir);
519 Assert.AreEqual(GAMSOptions.EExecMode.EchoAndPutOnlyToWorkdir, globalOpt.ExecMode, "expect same options " + GAMSOptions.EExecMode.EchoAndPutOnlyToWorkdir + " set");
520
521 globalOpt.ExecMode = (GAMSOptions.EExecMode.EchoAndPutProhibited);
522 Assert.AreEqual(GAMSOptions.EExecMode.EchoAndPutProhibited, globalOpt.ExecMode, "expect same options " + GAMSOptions.EExecMode.EchoAndPutProhibited + " set");
523
524 logger.Debug("Exiting TestGAMSOptions | testEnumExecMode");
525 }
526
527 //[Test]
528 //public void TestLookupEnumExecMode()
529 //{
530 // logger.Debug("Entering TestGAMSOptions | testLookupEnumExecMode");
531
532 // Assert.AreEqual("Lookup EverythingAllowed from EExecMode", GAMSOptions.EExecMode.EverythingAllowed, GAMSOptions.EExecMode.lookup(0));
533 // Assert.AreEqual("Lookup InteractiveShellsProhibited from EExecMode", GAMSOptions.EExecMode.InteractiveShellsProhibited, GAMSOptions.EExecMode.lookup(1));
534 // Assert.AreEqual("Lookup CallAndExecuteProhibited from EExecMode", GAMSOptions.EExecMode.CallAndExecuteProhibited, GAMSOptions.EExecMode.lookup(2));
535 // Assert.AreEqual("Lookup EchoAndPutOnlyToWorkdir from EExecMode", GAMSOptions.EExecMode.EchoAndPutOnlyToWorkdir, GAMSOptions.EExecMode.lookup(3));
536 // Assert.AreEqual("Lookup EchoAndPutProhibited from EExecMode", GAMSOptions.EExecMode.EchoAndPutProhibited, GAMSOptions.EExecMode.lookup(4));
537
538 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumExecMode");
539 //}
540
541
542 [Test]
543 public void TestEnumFDOpt()
544 {
545 logger.Debug("Entering TestGAMSOptions | testEnumFDOpt");
546
547 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GHAnalyticHNumericGradScale);
548 Assert.AreEqual(GAMSOptions.EFDOpt.GHAnalyticHNumericGradScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GHAnalyticHNumericGradScale + " set");
549
550 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GHAnalyticHNumericFuncScale);
551 Assert.AreEqual(GAMSOptions.EFDOpt.GHAnalyticHNumericFuncScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GHAnalyticHNumericFuncScale + " set");
552
553 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GAnalyticFHNumericGradScale);
554 Assert.AreEqual(GAMSOptions.EFDOpt.GAnalyticFHNumericGradScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GAnalyticFHNumericGradScale + " set");
555
556 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GAnalyticFHNumericFuncScale);
557 Assert.AreEqual(GAMSOptions.EFDOpt.GAnalyticFHNumericFuncScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GAnalyticFHNumericFuncScale + " set");
558
559 globalOpt.FDOpt = (GAMSOptions.EFDOpt.FGHNumericScale);
560 Assert.AreEqual(GAMSOptions.EFDOpt.FGHNumericScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.FGHNumericScale + " set");
561
562 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GHAnalyticHNumericGradNoScale);
563 Assert.AreEqual(GAMSOptions.EFDOpt.GHAnalyticHNumericGradNoScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GHAnalyticHNumericGradNoScale + " set");
564
565 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GHAnalyticHNumericFuncNoScale);
566 Assert.AreEqual(GAMSOptions.EFDOpt.GHAnalyticHNumericFuncNoScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GHAnalyticHNumericFuncNoScale + " set");
567
568 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GAnalyticFHNumericGradNoScale);
569 Assert.AreEqual(GAMSOptions.EFDOpt.GAnalyticFHNumericGradNoScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GAnalyticFHNumericGradNoScale + " set");
570
571 globalOpt.FDOpt = (GAMSOptions.EFDOpt.GAnalyticFHNumericFuncNoScale);
572 Assert.AreEqual(GAMSOptions.EFDOpt.GAnalyticFHNumericFuncNoScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.GAnalyticFHNumericFuncNoScale + " set");
573
574 globalOpt.FDOpt = (GAMSOptions.EFDOpt.FGHNumericNoScale);
575 Assert.AreEqual(GAMSOptions.EFDOpt.FGHNumericNoScale, globalOpt.FDOpt, "expect same options " + GAMSOptions.EFDOpt.FGHNumericNoScale + " set");
576
577 logger.Debug("Exiting TestGAMSOptions | testEnumFDOpt");
578 }
579
580 //[Test]
581 //public void TestLookupEnumFDOpt()
582 //{
583 // logger.Debug("Entering TestGAMSOptions | testLookupEnumFDOpt");
584
585 // Assert.AreEqual("Lookup GHAnalyticHNumericGradScale from EFDOpt", GAMSOptions.EFDOpt.GHAnalyticHNumericGradScale, GAMSOptions.EFDOpt.lookup(0));
586 // Assert.AreEqual("Lookup GHAnalyticHNumericFuncScale from EFDOpt", GAMSOptions.EFDOpt.GHAnalyticHNumericFuncScale, GAMSOptions.EFDOpt.lookup(1));
587 // Assert.AreEqual("Lookup GAnalyticFHNumericGradScale from EFDOpt", GAMSOptions.EFDOpt.GAnalyticFHNumericGradScale, GAMSOptions.EFDOpt.lookup(2));
588 // Assert.AreEqual("Lookup GAnalyticFHNumericFuncScale from EFDOpt", GAMSOptions.EFDOpt.GAnalyticFHNumericFuncScale, GAMSOptions.EFDOpt.lookup(3));
589 // Assert.AreEqual("Lookup FGHNumericScale from EFDOpt", GAMSOptions.EFDOpt.FGHNumericScale, GAMSOptions.EFDOpt.lookup(4));
590 // Assert.AreEqual("Lookup GHAnalyticHNumericGradNoScale from EFDOpt", GAMSOptions.EFDOpt.GHAnalyticHNumericGradNoScale, GAMSOptions.EFDOpt.lookup(10));
591 // Assert.AreEqual("Lookup GHAnalyticHNumericFuncNoScale from EFDOpt", GAMSOptions.EFDOpt.GHAnalyticHNumericFuncNoScale, GAMSOptions.EFDOpt.lookup(11));
592 // Assert.AreEqual("Lookup GAnalyticFHNumericGradNoScale from EFDOpt", GAMSOptions.EFDOpt.GAnalyticFHNumericGradNoScale, GAMSOptions.EFDOpt.lookup(12));
593 // Assert.AreEqual("Lookup GAnalyticFHNumericFuncNoScale from EFDOpt", GAMSOptions.EFDOpt.GAnalyticFHNumericFuncNoScale, GAMSOptions.EFDOpt.lookup(13));
594 // Assert.AreEqual("Lookup FGHNumericNoScale from EFDOpt", GAMSOptions.EFDOpt.FGHNumericNoScale, GAMSOptions.EFDOpt.lookup(14));
595
596 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumFDOpt");
597 //}
598
599
600 [Test]
601 public void TestEnumFileCase()
602 {
603 logger.Debug("Entering TestGAMSOptions | testEnumFileCase");
604
605 globalOpt.FileCase = (GAMSOptions.EFileCase.DefaultCase);
606 Assert.AreEqual(GAMSOptions.EFileCase.DefaultCase, globalOpt.FileCase, "expect same options " + GAMSOptions.EFileCase.DefaultCase + " set");
607
608 globalOpt.FileCase = (GAMSOptions.EFileCase.UpperCase);
609 Assert.AreEqual(GAMSOptions.EFileCase.UpperCase, globalOpt.FileCase, "expect same options " + GAMSOptions.EFileCase.UpperCase + " set");
610
611 globalOpt.FileCase = (GAMSOptions.EFileCase.LowerCase);
612 Assert.AreEqual(GAMSOptions.EFileCase.LowerCase, globalOpt.FileCase, "expect same options " + GAMSOptions.EFileCase.LowerCase + " set");
613
614 globalOpt.FileCase = (GAMSOptions.EFileCase.UpperCaseFileOnly);
615 Assert.AreEqual(GAMSOptions.EFileCase.UpperCaseFileOnly, globalOpt.FileCase, "expect same options " + GAMSOptions.EFileCase.UpperCaseFileOnly + " set");
616
617 globalOpt.FileCase = (GAMSOptions.EFileCase.LowerCaseFileOnly);
618 Assert.AreEqual(GAMSOptions.EFileCase.LowerCaseFileOnly, globalOpt.FileCase, "expect same options " + GAMSOptions.EFileCase.LowerCaseFileOnly + " set");
619
620 logger.Debug("Exiting TestGAMSOptions | testEnumFileCase");
621 }
622
623 //[Test]
624 //public void TestLookupEnumFileCase()
625 //{
626 // logger.Debug("Entering TestGAMSOptions | testLookupEnumFileCase");
627
628 // Assert.AreEqual("Lookup DefaultCase from EFileCase", GAMSOptions.EFileCase.DefaultCase, GAMSOptions.EFileCase.lookup(0));
629 // Assert.AreEqual("Lookup UpperCase from EFileCase", GAMSOptions.EFileCase.UpperCase, GAMSOptions.EFileCase.lookup(1));
630 // Assert.AreEqual("Lookup LowerCase from EFileCase", GAMSOptions.EFileCase.LowerCase, GAMSOptions.EFileCase.lookup(2));
631 // Assert.AreEqual("Lookup UpperCaseFileOnly from EFileCase", GAMSOptions.EFileCase.UpperCaseFileOnly, GAMSOptions.EFileCase.lookup(3));
632 // Assert.AreEqual("Lookup LowerCaseFileOnly from EFileCase", GAMSOptions.EFileCase.LowerCaseFileOnly, GAMSOptions.EFileCase.lookup(4));
633
634 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumFileCase");
635 //}
636
637
638 [Test]
639 public void TestEnumFiltered()
640 {
641 logger.Debug("Entering TestGAMSOptions | testEnumFiltered");
642
643 globalOpt.Filtered = (GAMSOptions.EFiltered.OffFiltered);
644 Assert.AreEqual(GAMSOptions.EFiltered.OffFiltered, globalOpt.Filtered, "expect same options " + GAMSOptions.EFiltered.OffFiltered + " set");
645
646 globalOpt.Filtered = (GAMSOptions.EFiltered.OnFiltered);
647 Assert.AreEqual(GAMSOptions.EFiltered.OnFiltered, globalOpt.Filtered, "expect same options " + GAMSOptions.EFiltered.OnFiltered + " set");
648
649 logger.Debug("Exiting TestGAMSOptions | testEnumFiltered");
650 }
651
652 //[Test]
653 //public void TestLookupEnumFiltered()
654 //{
655 // logger.Debug("Entering TestGAMSOptions | testLookupEnumFiltered");
656
657 // Assert.AreEqual("Lookup off from EFiltered", GAMSOptions.EFiltered.OffFiltered, GAMSOptions.EFiltered.lookup("off"));
658 // Assert.AreEqual("Lookup on from EFiltered", GAMSOptions.EFiltered.OnFiltered, GAMSOptions.EFiltered.lookup("on"));
659
660 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumFiltered");
661 //}
662
663
664 [Test]
665 public void TestEnumForceWork()
666 {
667 logger.Debug("Entering TestGAMSOptions | testEnumForceWork");
668
669 globalOpt.ForceWork = (GAMSOptions.EForceWork.NoTranslation);
670 Assert.AreEqual(GAMSOptions.EForceWork.NoTranslation, globalOpt.ForceWork, "expect same options " + GAMSOptions.EForceWork.NoTranslation + " set");
671
672 globalOpt.ForceWork = (GAMSOptions.EForceWork.TryTranslation);
673 Assert.AreEqual(GAMSOptions.EForceWork.TryTranslation, globalOpt.ForceWork, "expect same options " + GAMSOptions.EForceWork.TryTranslation + " set");
674
675 logger.Debug("Exiting TestGAMSOptions | testEnumForceWork");
676 }
677
678 //[Test]
679 //public void TestLookupEnumForceWork()
680 //{
681 // logger.Debug("Entering TestGAMSOptions | testLookupEnumForceWork");
682
683 // Assert.AreEqual("Lookup NoTranslation from EForceWork", GAMSOptions.EForceWork.NoTranslation, GAMSOptions.EForceWork.lookup(0));
684 // Assert.AreEqual("Lookup TryTranslation from EForceWork", GAMSOptions.EForceWork.TryTranslation, GAMSOptions.EForceWork.lookup(1));
685
686 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumForceWork");
687 //}
688
689
690 [Test]
691 public void TestEnumFreeEmbeddedPython()
692 {
693 logger.Debug("Entering TestGAMSOptions | testEnumFreeEmbeddedPython");
694
695 globalOpt.FreeEmbeddedPython = (GAMSOptions.EFreeEmbeddedPython.Off);
696 Assert.AreEqual(GAMSOptions.EFreeEmbeddedPython.Off, globalOpt.FreeEmbeddedPython, "expect same options " + GAMSOptions.EFreeEmbeddedPython.Off + " set");
697
698 globalOpt.FreeEmbeddedPython = (GAMSOptions.EFreeEmbeddedPython.On);
699 Assert.AreEqual(GAMSOptions.EFreeEmbeddedPython.On, globalOpt.FreeEmbeddedPython, "expect same options " + GAMSOptions.EFreeEmbeddedPython.On + " set");
700
701 logger.Debug("Exiting TestGAMSOptions | testEnumFreeEmbeddedPython");
702 }
703
704 //[Test]
705 //public void TestLookupEnumFreeEmbeddedPython()
706 //{
707 // logger.Debug("Entering TestGAMSOptions | testLookupEnumFreeEmbeddedPython");
708
709 // Assert.AreEqual("Lookup Off from EFreeEmbeddedPython", GAMSOptions.EFreeEmbeddedPython.Off, GAMSOptions.EFreeEmbeddedPython.lookup(0));
710 // Assert.AreEqual("Lookup On from EFreeEmbeddedPython", GAMSOptions.EFreeEmbeddedPython.On, GAMSOptions.EFreeEmbeddedPython.lookup(1));
711
712 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumFreeEmbeddedPython");
713 //}
714
715
716 [Test]
717 public void TestEnumgdxCompress()
718 {
719 logger.Debug("Entering TestGAMSOptions | testEnumgdxCompress");
720
721 globalOpt.gdxCompress = (GAMSOptions.EgdxCompress.DoNotCompressGDX);
722 Assert.AreEqual(GAMSOptions.EgdxCompress.DoNotCompressGDX, globalOpt.gdxCompress, "expect same options " + GAMSOptions.EgdxCompress.DoNotCompressGDX + " set");
723
724 globalOpt.gdxCompress = (GAMSOptions.EgdxCompress.CompressGDX);
725 Assert.AreEqual(GAMSOptions.EgdxCompress.CompressGDX, globalOpt.gdxCompress, "expect same options " + GAMSOptions.EgdxCompress.CompressGDX + " set");
726
727 logger.Debug("Exiting TestGAMSOptions | testEnumgdxCompress");
728 }
729
730 //[Test]
731 //public void TestLookupEnumgdxCompress()
732 //{
733 // logger.Debug("Entering TestGAMSOptions | testLookupEnumgdxCompress");
734
735 // Assert.AreEqual("Lookup DoNotCompressGDX from EgdxCompress", GAMSOptions.EgdxCompress.DoNotCompressGDX, GAMSOptions.EgdxCompress.lookup(0));
736 // Assert.AreEqual("Lookup CompressGDX from EgdxCompress", GAMSOptions.EgdxCompress.CompressGDX, GAMSOptions.EgdxCompress.lookup(1));
737
738 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumgdxCompress");
739 //}
740
741
742 [Test]
743 public void TestEnumgdxConvert()
744 {
745 logger.Debug("Entering TestGAMSOptions | testEnumgdxConvert");
746
747 globalOpt.gdxConvert = (GAMSOptions.EgdxConvert.Version5);
748 Assert.AreEqual(GAMSOptions.EgdxConvert.Version5, globalOpt.gdxConvert, "expect same options " + GAMSOptions.EgdxConvert.Version5 + " set");
749
750 globalOpt.gdxConvert = (GAMSOptions.EgdxConvert.Version6);
751 Assert.AreEqual(GAMSOptions.EgdxConvert.Version6, globalOpt.gdxConvert, "expect same options " + GAMSOptions.EgdxConvert.Version6 + " set");
752
753 globalOpt.gdxConvert = (GAMSOptions.EgdxConvert.Version7);
754 Assert.AreEqual(GAMSOptions.EgdxConvert.Version7, globalOpt.gdxConvert, "expect same options " + GAMSOptions.EgdxConvert.Version7 + " set");
755
756 logger.Debug("Exiting TestGAMSOptions | testEnumgdxConvert");
757 }
758
759 //[Test]
760 //public void TestLookupEnumgdxConvert()
761 //{
762 // logger.Debug("Entering TestGAMSOptions | testLookupEnumgdxConvert");
763
764 // Assert.AreEqual("Lookup v5 from EgdxConvert", GAMSOptions.EgdxConvert.Version5, GAMSOptions.EgdxConvert.lookup("v5"));
765 // Assert.AreEqual("Lookup v6 from EgdxConvert", GAMSOptions.EgdxConvert.Version6, GAMSOptions.EgdxConvert.lookup("v6"));
766 // Assert.AreEqual("Lookup v7 from EgdxConvert", GAMSOptions.EgdxConvert.Version7, GAMSOptions.EgdxConvert.lookup("v7"));
767
768 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumgdxConvert");
769 //}
770
771
772 [Test]
773 public void TestEnumgdxUels()
774 {
775 logger.Debug("Entering TestGAMSOptions | testEnumgdxUels");
776
777 globalOpt.gdxUels = (GAMSOptions.EgdxUels.squeezed);
778 Assert.AreEqual(GAMSOptions.EgdxUels.squeezed, globalOpt.gdxUels, "expect same options " + GAMSOptions.EgdxUels.squeezed + " set");
779
780 globalOpt.gdxUels = (GAMSOptions.EgdxUels.full);
781 Assert.AreEqual(GAMSOptions.EgdxUels.full, globalOpt.gdxUels, "expect same options " + GAMSOptions.EgdxUels.full + " set");
782
783 logger.Debug("Exiting TestGAMSOptions | testEnumgdxUels");
784 }
785
786 //[Test]
787 //public void TestLookupEnumgdxUels()
788 //{
789 // logger.Debug("Entering TestGAMSOptions | testLookupEnumgdxUels");
790
791 // Assert.AreEqual("Lookup Squeezed from EgdxUels", GAMSOptions.EgdxUels.squeezed, GAMSOptions.EgdxUels.lookup("Squeezed"));
792 // Assert.AreEqual("Lookup Full from EgdxUels", GAMSOptions.EgdxUels.full, GAMSOptions.EgdxUels.lookup("Full"));
793
794 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumgdxUels");
795 //}
796
797
798 [Test]
799 public void TestEnumHoldFixed()
800 {
801 logger.Debug("Entering TestGAMSOptions | testEnumHoldFixed");
802
803 globalOpt.HoldFixed = (GAMSOptions.EHoldFixed.FixedVarsNotTreatedAsConstants);
804 Assert.AreEqual(GAMSOptions.EHoldFixed.FixedVarsNotTreatedAsConstants, globalOpt.HoldFixed, "expect same options " + GAMSOptions.EHoldFixed.FixedVarsNotTreatedAsConstants + " set");
805
806 globalOpt.HoldFixed = (GAMSOptions.EHoldFixed.FixedVarsTreatedAsConstants);
807 Assert.AreEqual(GAMSOptions.EHoldFixed.FixedVarsTreatedAsConstants, globalOpt.HoldFixed, "expect same options " + GAMSOptions.EHoldFixed.FixedVarsTreatedAsConstants + " set");
808
809 logger.Debug("Exiting TestGAMSOptions | testEnumHoldFixed");
810 }
811
812 //[Test]
813 //public void TestLookupEnumHoldFixed()
814 //{
815 // logger.Debug("Entering TestGAMSOptions | testLookupEnumHoldFixed");
816
817 // Assert.AreEqual("Lookup FixedVarsNotTreatedAsConstants from EHoldFixed", GAMSOptions.EHoldFixed.FixedVarsNotTreatedAsConstants, GAMSOptions.EHoldFixed.lookup(0));
818 // Assert.AreEqual("Lookup FixedVarsTreatedAsConstants from EHoldFixed", GAMSOptions.EHoldFixed.FixedVarsTreatedAsConstants, GAMSOptions.EHoldFixed.lookup(1));
819
820 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumHoldFixed");
821 //}
822
823
824 [Test]
825 public void TestEnumHoldFixedAsync()
826 {
827 logger.Debug("Entering TestGAMSOptions | testEnumHoldFixedAsync");
828
829 globalOpt.HoldFixedAsync = (GAMSOptions.EHoldFixedAsync.Off);
830 Assert.AreEqual(GAMSOptions.EHoldFixedAsync.Off, globalOpt.HoldFixedAsync, "expect same options " + GAMSOptions.EHoldFixedAsync.Off + " set");
831
832 globalOpt.HoldFixedAsync = (GAMSOptions.EHoldFixedAsync.On);
833 Assert.AreEqual(GAMSOptions.EHoldFixedAsync.On, globalOpt.HoldFixedAsync, "expect same options " + GAMSOptions.EHoldFixedAsync.On + " set");
834
835 logger.Debug("Exiting TestGAMSOptions | testEnumHoldFixedAsync");
836 }
837
838 //[Test]
839 //public void TestLookupEnumHoldFixedAsync()
840 //{
841 // logger.Debug("Entering TestGAMSOptions | testLookupEnumHoldFixedAsync");
842
843 // Assert.AreEqual("Lookup Off from EHoldFixedAsync", GAMSOptions.EHoldFixedAsync.Off, GAMSOptions.EHoldFixedAsync.lookup(0));
844 // Assert.AreEqual("Lookup On from EHoldFixedAsync", GAMSOptions.EHoldFixedAsync.On, GAMSOptions.EHoldFixedAsync.lookup(1));
845
846 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumHoldFixedAsync");
847 //}
848
849
850 [Test]
851 public void TestEnumInteractiveSolver()
852 {
853 logger.Debug("Entering TestGAMSOptions | testEnumInteractiveSolver");
854
855 globalOpt.InteractiveSolver = (GAMSOptions.EInteractiveSolver.NoInteraction);
856 Assert.AreEqual(GAMSOptions.EInteractiveSolver.NoInteraction, globalOpt.InteractiveSolver, "expect same options " + GAMSOptions.EInteractiveSolver.NoInteraction + " set");
857
858 globalOpt.InteractiveSolver = (GAMSOptions.EInteractiveSolver.AllowInteraction);
859 Assert.AreEqual(GAMSOptions.EInteractiveSolver.AllowInteraction, globalOpt.InteractiveSolver, "expect same options " + GAMSOptions.EInteractiveSolver.AllowInteraction + " set");
860
861 logger.Debug("Exiting TestGAMSOptions | testEnumInteractiveSolver");
862 }
863
864 //[Test]
865 //public void TestLookupEnumInteractiveSolver()
866 //{
867 // logger.Debug("Entering TestGAMSOptions | testLookupEnumInteractiveSolver");
868
869 // Assert.AreEqual("Lookup NoInteraction from EInteractiveSolver", GAMSOptions.EInteractiveSolver.NoInteraction, GAMSOptions.EInteractiveSolver.lookup(0));
870 // Assert.AreEqual("Lookup AllowInteraction from EInteractiveSolver", GAMSOptions.EInteractiveSolver.AllowInteraction, GAMSOptions.EInteractiveSolver.lookup(1));
871
872 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumInteractiveSolver");
873 //}
874
875
876 [Test]
877 public void TestEnumIntVarUp()
878 {
879 logger.Debug("Entering TestGAMSOptions | testEnumIntVarUp");
880
881 globalOpt.IntVarUp = (GAMSOptions.EIntVarUp.INF);
882 Assert.AreEqual(GAMSOptions.EIntVarUp.INF, globalOpt.IntVarUp, "expect same options " + GAMSOptions.EIntVarUp.INF + " set");
883
884 globalOpt.IntVarUp = (GAMSOptions.EIntVarUp.Pass100ToSolver);
885 Assert.AreEqual(GAMSOptions.EIntVarUp.Pass100ToSolver, globalOpt.IntVarUp, "expect same options " + GAMSOptions.EIntVarUp.Pass100ToSolver + " set");
886
887 globalOpt.IntVarUp = (GAMSOptions.EIntVarUp.INFandLog);
888 Assert.AreEqual(GAMSOptions.EIntVarUp.INFandLog, globalOpt.IntVarUp, "expect same options " + GAMSOptions.EIntVarUp.INFandLog + " set");
889
890 globalOpt.IntVarUp = (GAMSOptions.EIntVarUp.Pass100ToSolverAndError);
891 Assert.AreEqual(GAMSOptions.EIntVarUp.Pass100ToSolverAndError, globalOpt.IntVarUp, "expect same options " + GAMSOptions.EIntVarUp.Pass100ToSolverAndError + " set");
892
893 logger.Debug("Exiting TestGAMSOptions | testEnumIntVarUp");
894 }
895
896 //[Test]
897 //public void TestLookupEnumIntVarUp()
898 //{
899 // logger.Debug("Entering TestGAMSOptions | testLookupEnumIntVarUp");
900
901 // Assert.AreEqual("Lookup INF from EIntVarUp", GAMSOptions.EIntVarUp.INF, GAMSOptions.EIntVarUp.lookup(0));
902 // Assert.AreEqual("Lookup Pass100ToSolver from EIntVarUp", GAMSOptions.EIntVarUp.Pass100ToSolver, GAMSOptions.EIntVarUp.lookup(1));
903 // Assert.AreEqual("Lookup INFandLog from EIntVarUp", GAMSOptions.EIntVarUp.INFandLog, GAMSOptions.EIntVarUp.lookup(2));
904 // Assert.AreEqual("Lookup Pass100ToSolverAndError from EIntVarUp", GAMSOptions.EIntVarUp.Pass100ToSolverAndError, GAMSOptions.EIntVarUp.lookup(3));
905
906 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumIntVarUp");
907 //}
908
909
910 [Test]
911 public void TestEnumKeep()
912 {
913 logger.Debug("Entering TestGAMSOptions | testEnumKeep");
914
915 globalOpt.Keep = (GAMSOptions.EKeep.DeleteProcDir);
916 Assert.AreEqual(GAMSOptions.EKeep.DeleteProcDir, globalOpt.Keep, "expect same options " + GAMSOptions.EKeep.DeleteProcDir + " set");
917
918 globalOpt.Keep = (GAMSOptions.EKeep.KeepProcDir);
919 Assert.AreEqual(GAMSOptions.EKeep.KeepProcDir, globalOpt.Keep, "expect same options " + GAMSOptions.EKeep.KeepProcDir + " set");
920
921 logger.Debug("Exiting TestGAMSOptions | testEnumKeep");
922 }
923
924 //[Test]
925 //public void TestLookupEnumKeep()
926 //{
927 // logger.Debug("Entering TestGAMSOptions | testLookupEnumKeep");
928
929 // Assert.AreEqual("Lookup DeleteProcDir from EKeep", GAMSOptions.EKeep.DeleteProcDir, GAMSOptions.EKeep.lookup(0));
930 // Assert.AreEqual("Lookup KeepProcDir from EKeep", GAMSOptions.EKeep.KeepProcDir, GAMSOptions.EKeep.lookup(1));
931
932 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumKeep");
933 //}
934
935
936 [Test]
937 public void TestEnumListing()
938 {
939 logger.Debug("Entering TestGAMSOptions | testEnumListing");
940
941 globalOpt.Listing = (GAMSOptions.EListing.OffListing);
942 Assert.AreEqual(GAMSOptions.EListing.OffListing, globalOpt.Listing, "expect same options " + GAMSOptions.EListing.OffListing + " set");
943
944 globalOpt.Listing = (GAMSOptions.EListing.OnListing);
945 Assert.AreEqual(GAMSOptions.EListing.OnListing, globalOpt.Listing, "expect same options " + GAMSOptions.EListing.OnListing + " set");
946
947 logger.Debug("Exiting TestGAMSOptions | testEnumListing");
948 }
949
950 //[Test]
951 //public void TestLookupEnumListing()
952 //{
953 // logger.Debug("Entering TestGAMSOptions | testLookupEnumListing");
954
955 // Assert.AreEqual("Lookup off from EListing", GAMSOptions.EListing.OffListing, GAMSOptions.EListing.lookup("off"));
956 // Assert.AreEqual("Lookup on from EListing", GAMSOptions.EListing.OnListing, GAMSOptions.EListing.lookup("on"));
957
958 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumListing");
959 //}
960
961
962 [Test]
963 public void TestEnumLogLine()
964 {
965 logger.Debug("Entering TestGAMSOptions | testEnumLogLine");
966
967 globalOpt.LogLine = (GAMSOptions.ELogLine.NoTracing);
968 Assert.AreEqual(GAMSOptions.ELogLine.NoTracing, globalOpt.LogLine, "expect same options " + GAMSOptions.ELogLine.NoTracing + " set");
969
970 globalOpt.LogLine = (GAMSOptions.ELogLine.MinimumTracing);
971 Assert.AreEqual(GAMSOptions.ELogLine.MinimumTracing, globalOpt.LogLine, "expect same options " + GAMSOptions.ELogLine.MinimumTracing + " set");
972
973 globalOpt.LogLine = (GAMSOptions.ELogLine.Automatic);
974 Assert.AreEqual(GAMSOptions.ELogLine.Automatic, globalOpt.LogLine, "expect same options " + GAMSOptions.ELogLine.Automatic + " set");
975
976 logger.Debug("Exiting TestGAMSOptions | testEnumLogLine");
977 }
978
979 //[Test]
980 //public void TestLookupEnumLogLine()
981 //{
982 // logger.Debug("Entering TestGAMSOptions | testLookupEnumLogLine");
983
984 // Assert.AreEqual("Lookup NoTracing from ELogLine", GAMSOptions.ELogLine.NoTracing, GAMSOptions.ELogLine.lookup(0));
985 // Assert.AreEqual("Lookup MinimumTracing from ELogLine", GAMSOptions.ELogLine.MinimumTracing, GAMSOptions.ELogLine.lookup(1));
986 // Assert.AreEqual("Lookup Automatic from ELogLine", GAMSOptions.ELogLine.Automatic, GAMSOptions.ELogLine.lookup(2));
987
988 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumLogLine");
989 //}
990
991
992 [Test]
993 public void TestEnumLstTitleLeftAligned()
994 {
995 logger.Debug("Entering TestGAMSOptions | testEnumLstTitleLeftAligned");
996
997 globalOpt.LstTitleLeftAligned = (GAMSOptions.ELstTitleLeftAligned.Off);
998 Assert.AreEqual(GAMSOptions.ELstTitleLeftAligned.Off, globalOpt.LstTitleLeftAligned, "expect same options " + GAMSOptions.ELstTitleLeftAligned.Off + " set");
999
1000 globalOpt.LstTitleLeftAligned = (GAMSOptions.ELstTitleLeftAligned.On);
1001 Assert.AreEqual(GAMSOptions.ELstTitleLeftAligned.On, globalOpt.LstTitleLeftAligned, "expect same options " + GAMSOptions.ELstTitleLeftAligned.On + " set");
1002
1003 logger.Debug("Exiting TestGAMSOptions | testEnumLstTitleLeftAligned");
1004 }
1005
1006 //[Test]
1007 //public void TestLookupEnumLstTitleLeftAligned()
1008 //{
1009 // logger.Debug("Entering TestGAMSOptions | testLookupEnumLstTitleLeftAligned");
1010
1011 // Assert.AreEqual("Lookup Off from ELstTitleLeftAligned", GAMSOptions.ELstTitleLeftAligned.Off, GAMSOptions.ELstTitleLeftAligned.lookup(0));
1012 // Assert.AreEqual("Lookup On from ELstTitleLeftAligned", GAMSOptions.ELstTitleLeftAligned.On, GAMSOptions.ELstTitleLeftAligned.lookup(1));
1013
1014 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumLstTitleLeftAligned");
1015 //}
1016
1017
1018 [Test]
1019 public void TestEnumNoNewVarEqu()
1020 {
1021 logger.Debug("Entering TestGAMSOptions | testEnumNoNewVarEqu");
1022
1023 globalOpt.NoNewVarEqu = (GAMSOptions.ENoNewVarEqu.AllowNewVarEqu);
1024 Assert.AreEqual(GAMSOptions.ENoNewVarEqu.AllowNewVarEqu, globalOpt.NoNewVarEqu, "expect same options " + GAMSOptions.ENoNewVarEqu.AllowNewVarEqu + " set");
1025
1026 globalOpt.NoNewVarEqu = (GAMSOptions.ENoNewVarEqu.DoNotAllowNewVarEqu);
1027 Assert.AreEqual(GAMSOptions.ENoNewVarEqu.DoNotAllowNewVarEqu, globalOpt.NoNewVarEqu, "expect same options " + GAMSOptions.ENoNewVarEqu.DoNotAllowNewVarEqu + " set");
1028
1029 logger.Debug("Exiting TestGAMSOptions | testEnumNoNewVarEqu");
1030 }
1031
1032 //[Test]
1033 //public void TestLookupEnumNoNewVarEqu()
1034 //{
1035 // logger.Debug("Entering TestGAMSOptions | testLookupEnumNoNewVarEqu");
1036
1037 // Assert.AreEqual("Lookup AllowNewVarEqu from ENoNewVarEqu", GAMSOptions.ENoNewVarEqu.AllowNewVarEqu, GAMSOptions.ENoNewVarEqu.lookup(0));
1038 // Assert.AreEqual("Lookup DoNotAllowNewVarEqu from ENoNewVarEqu", GAMSOptions.ENoNewVarEqu.DoNotAllowNewVarEqu, GAMSOptions.ENoNewVarEqu.lookup(1));
1039
1040 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumNoNewVarEqu");
1041 //}
1042
1043
1044 [Test]
1045 public void TestEnumOn115()
1046 {
1047 logger.Debug("Entering TestGAMSOptions | testEnumOn115");
1048
1049 globalOpt.On115 = (GAMSOptions.EOn115.NoMessages);
1050 Assert.AreEqual(GAMSOptions.EOn115.NoMessages, globalOpt.On115, "expect same options " + GAMSOptions.EOn115.NoMessages + " set");
1051
1052 globalOpt.On115 = (GAMSOptions.EOn115.IssueMessages);
1053 Assert.AreEqual(GAMSOptions.EOn115.IssueMessages, globalOpt.On115, "expect same options " + GAMSOptions.EOn115.IssueMessages + " set");
1054
1055 logger.Debug("Exiting TestGAMSOptions | testEnumOn115");
1056 }
1057
1058 //[Test]
1059 //public void TestLookupEnumOn115()
1060 //{
1061 // logger.Debug("Entering TestGAMSOptions | testLookupEnumOn115");
1062
1063 // Assert.AreEqual("Lookup NoMessages from EOn115", GAMSOptions.EOn115.NoMessages, GAMSOptions.EOn115.lookup(0));
1064 // Assert.AreEqual("Lookup IssueMessages from EOn115", GAMSOptions.EOn115.IssueMessages, GAMSOptions.EOn115.lookup(1));
1065
1066 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumOn115");
1067 //}
1068
1069
1070 [Test]
1071 public void TestEnumPageContr()
1072 {
1073 logger.Debug("Entering TestGAMSOptions | testEnumPageContr");
1074
1075 globalOpt.PageContr = (GAMSOptions.EPageContr.NoPageContrWithPadding);
1076 Assert.AreEqual(GAMSOptions.EPageContr.NoPageContrWithPadding, globalOpt.PageContr, "expect same options " + GAMSOptions.EPageContr.NoPageContrWithPadding + " set");
1077
1078 globalOpt.PageContr = (GAMSOptions.EPageContr.FortranStyle);
1079 Assert.AreEqual(GAMSOptions.EPageContr.FortranStyle, globalOpt.PageContr, "expect same options " + GAMSOptions.EPageContr.FortranStyle + " set");
1080
1081 globalOpt.PageContr = (GAMSOptions.EPageContr.NoPageContrNoPadding);
1082 Assert.AreEqual(GAMSOptions.EPageContr.NoPageContrNoPadding, globalOpt.PageContr, "expect same options " + GAMSOptions.EPageContr.NoPageContrNoPadding + " set");
1083
1084 globalOpt.PageContr = (GAMSOptions.EPageContr.FormfeedCharNewPage);
1085 Assert.AreEqual(GAMSOptions.EPageContr.FormfeedCharNewPage, globalOpt.PageContr, "expect same options " + GAMSOptions.EPageContr.FormfeedCharNewPage + " set");
1086
1087 logger.Debug("Exiting TestGAMSOptions | testEnumPageContr");
1088 }
1089
1090 //[Test]
1091 //public void TestLookupEnumPageContr()
1092 //{
1093 // logger.Debug("Entering TestGAMSOptions | testLookupEnumPageContr");
1094
1095 // Assert.AreEqual("Lookup NoPageContrWithPadding from EPageContr", GAMSOptions.EPageContr.NoPageContrWithPadding, GAMSOptions.EPageContr.lookup(0));
1096 // Assert.AreEqual("Lookup FortranStyle from EPageContr", GAMSOptions.EPageContr.FortranStyle, GAMSOptions.EPageContr.lookup(1));
1097 // Assert.AreEqual("Lookup NoPageContrNoPadding from EPageContr", GAMSOptions.EPageContr.NoPageContrNoPadding, GAMSOptions.EPageContr.lookup(2));
1098 // Assert.AreEqual("Lookup FormfeedCharNewPage from EPageContr", GAMSOptions.EPageContr.FormfeedCharNewPage, GAMSOptions.EPageContr.lookup(3));
1099
1100 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumPageContr");
1101 //}
1102
1103
1104 [Test]
1105 public void TestEnumPrefixLoadPath()
1106 {
1107 logger.Debug("Entering TestGAMSOptions | testEnumPrefixLoadPath");
1108
1109 globalOpt.PrefixLoadPath = (GAMSOptions.EPrefixLoadPath.Off);
1110 Assert.AreEqual(GAMSOptions.EPrefixLoadPath.Off, globalOpt.PrefixLoadPath, "expect same options " + GAMSOptions.EPrefixLoadPath.Off + " set");
1111
1112 globalOpt.PrefixLoadPath = (GAMSOptions.EPrefixLoadPath.On);
1113 Assert.AreEqual(GAMSOptions.EPrefixLoadPath.On, globalOpt.PrefixLoadPath, "expect same options " + GAMSOptions.EPrefixLoadPath.On + " set");
1114
1115 logger.Debug("Exiting TestGAMSOptions | testEnumPrefixLoadPath");
1116 }
1117
1118 //[Test]
1119 //public void TestLookupEnumPrefixLoadPath()
1120 //{
1121 // logger.Debug("Entering TestGAMSOptions | testLookupEnumPrefixLoadPath");
1122
1123 // Assert.AreEqual("Lookup Off from EPrefixLoadPath", GAMSOptions.EPrefixLoadPath.Off, GAMSOptions.EPrefixLoadPath.lookup(0));
1124 // Assert.AreEqual("Lookup On from EPrefixLoadPath", GAMSOptions.EPrefixLoadPath.On, GAMSOptions.EPrefixLoadPath.lookup(1));
1125
1126 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumPrefixLoadPath");
1127 //}
1128
1129
1130 [Test]
1131 public void TestEnumPreviousWork()
1132 {
1133 logger.Debug("Entering TestGAMSOptions | testEnumPreviousWork");
1134
1135 globalOpt.PreviousWork = (GAMSOptions.EPreviousWork.Off);
1136 Assert.AreEqual(GAMSOptions.EPreviousWork.Off, globalOpt.PreviousWork, "expect same options " + GAMSOptions.EPreviousWork.Off + " set");
1137
1138 globalOpt.PreviousWork = (GAMSOptions.EPreviousWork.On);
1139 Assert.AreEqual(GAMSOptions.EPreviousWork.On, globalOpt.PreviousWork, "expect same options " + GAMSOptions.EPreviousWork.On + " set");
1140
1141 logger.Debug("Exiting TestGAMSOptions | testEnumPreviousWork");
1142 }
1143
1144 //[Test]
1145 //public void TestLookupEnumPreviousWork()
1146 //{
1147 // logger.Debug("Entering TestGAMSOptions | testLookupEnumPreviousWork");
1148
1149 // Assert.AreEqual("Lookup Off from EPreviousWork", GAMSOptions.EPreviousWork.Off, GAMSOptions.EPreviousWork.lookup(0));
1150 // Assert.AreEqual("Lookup On from EPreviousWork", GAMSOptions.EPreviousWork.On, GAMSOptions.EPreviousWork.lookup(1));
1151
1152 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumPreviousWork");
1153 //}
1154
1155
1156 [Test]
1157 public void TestEnumProcTreeMemMonitor()
1158 {
1159 logger.Debug("Entering TestGAMSOptions | testEnumProcTreeMemMonitor");
1160
1161 globalOpt.ProcTreeMemMonitor = (GAMSOptions.EProcTreeMemMonitor.Off);
1162 Assert.AreEqual(GAMSOptions.EProcTreeMemMonitor.Off, globalOpt.ProcTreeMemMonitor, "expect same options " + GAMSOptions.EProcTreeMemMonitor.Off + " set");
1163
1164 globalOpt.ProcTreeMemMonitor = (GAMSOptions.EProcTreeMemMonitor.On);
1165 Assert.AreEqual(GAMSOptions.EProcTreeMemMonitor.On, globalOpt.ProcTreeMemMonitor, "expect same options " + GAMSOptions.EProcTreeMemMonitor.On + " set");
1166
1167 logger.Debug("Exiting TestGAMSOptions | testEnumProcTreeMemMonitor");
1168 }
1169
1170 //[Test]
1171 //public void TestLookupEnumProcTreeMemMonitor()
1172 //{
1173 // logger.Debug("Entering TestGAMSOptions | testLookupEnumProcTreeMemMonitor");
1174
1175 // Assert.AreEqual("Lookup Off from EProcTreeMemMonitor", GAMSOptions.EProcTreeMemMonitor.Off, GAMSOptions.EProcTreeMemMonitor.lookup(0));
1176 // Assert.AreEqual("Lookup On from EProcTreeMemMonitor", GAMSOptions.EProcTreeMemMonitor.On, GAMSOptions.EProcTreeMemMonitor.lookup(1));
1177
1178 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumProcTreeMemMonitor");
1179 //}
1180
1181
1182 [Test]
1183 public void TestEnumPutNR()
1184 {
1185 logger.Debug("Entering TestGAMSOptions | testEnumPutNR");
1186
1187 globalOpt.PutNR = (GAMSOptions.EPutNR.ForE);
1188 Assert.AreEqual(GAMSOptions.EPutNR.ForE, globalOpt.PutNR, "expect same options " + GAMSOptions.EPutNR.ForE + " set");
1189
1190 globalOpt.PutNR = (GAMSOptions.EPutNR.Rounded);
1191 Assert.AreEqual(GAMSOptions.EPutNR.Rounded, globalOpt.PutNR, "expect same options " + GAMSOptions.EPutNR.Rounded + " set");
1192
1193 globalOpt.PutNR = (GAMSOptions.EPutNR.Scientific);
1194 Assert.AreEqual(GAMSOptions.EPutNR.Scientific, globalOpt.PutNR, "expect same options " + GAMSOptions.EPutNR.Scientific + " set");
1195
1196 globalOpt.PutNR = (GAMSOptions.EPutNR.RoundedFloatingDec);
1197 Assert.AreEqual(GAMSOptions.EPutNR.RoundedFloatingDec, globalOpt.PutNR, "expect same options " + GAMSOptions.EPutNR.RoundedFloatingDec + " set");
1198
1199 globalOpt.PutNR = (GAMSOptions.EPutNR.ForEFloatingDec);
1200 Assert.AreEqual(GAMSOptions.EPutNR.ForEFloatingDec, globalOpt.PutNR, "expect same options " + GAMSOptions.EPutNR.ForEFloatingDec + " set");
1201
1202 logger.Debug("Exiting TestGAMSOptions | testEnumPutNR");
1203 }
1204
1205 //[Test]
1206 //public void TestLookupEnumPutNR()
1207 //{
1208 // logger.Debug("Entering TestGAMSOptions | testLookupEnumPutNR");
1209
1210 // Assert.AreEqual("Lookup ForE from EPutNR", GAMSOptions.EPutNR.ForE, GAMSOptions.EPutNR.lookup(0));
1211 // Assert.AreEqual("Lookup Rounded from EPutNR", GAMSOptions.EPutNR.Rounded, GAMSOptions.EPutNR.lookup(1));
1212 // Assert.AreEqual("Lookup Scientific from EPutNR", GAMSOptions.EPutNR.Scientific, GAMSOptions.EPutNR.lookup(2));
1213 // Assert.AreEqual("Lookup RoundedFloatingDec from EPutNR", GAMSOptions.EPutNR.RoundedFloatingDec, GAMSOptions.EPutNR.lookup(3));
1214 // Assert.AreEqual("Lookup ForEFloatingDec from EPutNR", GAMSOptions.EPutNR.ForEFloatingDec, GAMSOptions.EPutNR.lookup(4));
1215
1216 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumPutNR");
1217 //}
1218
1219 [Test]
1220 public void TestEnumReferenceLineNo()
1221 {
1222 logger.Debug("Entering TestGAMSOptions | testEnumReferenceLineNo");
1223
1224 globalOpt.ReferenceLineNo = (GAMSOptions.EReferenceLineNo.ActualLineNumber);
1225 Assert.AreEqual(GAMSOptions.EReferenceLineNo.ActualLineNumber, globalOpt.ReferenceLineNo, "expect same options " + GAMSOptions.EReferenceLineNo.ActualLineNumber + " set");
1226
1227 globalOpt.ReferenceLineNo = (GAMSOptions.EReferenceLineNo.StatementStart);
1228 Assert.AreEqual(GAMSOptions.EReferenceLineNo.StatementStart, globalOpt.ReferenceLineNo, "expect same options " + GAMSOptions.EReferenceLineNo.StatementStart + " set");
1229
1230 logger.Debug("Exiting TestGAMSOptions | testEnumReferenceLineNo");
1231 }
1232
1233 //[Test]
1234 //public void TestLookupEnumReferenceLineNo()
1235 //{
1236 // logger.Debug("Entering TestGAMSOptions | testLookupEnumReferenceLineNo");
1237
1238 // Assert.AreEqual("Lookup actual from EReferenceLineNo", GAMSOptions.EReferenceLineNo.ActualLineNumber, GAMSOptions.EReferenceLineNo.lookup("actual"));
1239 // Assert.AreEqual("Lookup start from EReferenceLineNo", GAMSOptions.EReferenceLineNo.StatementStart, GAMSOptions.EReferenceLineNo.lookup("start"));
1240
1241 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumReferenceLineNo");
1242 //}
1243
1244
1245 [Test]
1246 public void TestEnumSavePoint()
1247 {
1248 logger.Debug("Entering TestGAMSOptions | testEnumSavePoint");
1249
1250 globalOpt.SavePoint = (GAMSOptions.ESavePoint.NoPointFile);
1251 Assert.AreEqual(GAMSOptions.ESavePoint.NoPointFile, globalOpt.SavePoint, "expect same options " + GAMSOptions.ESavePoint.NoPointFile + " set");
1252
1253 globalOpt.SavePoint = (GAMSOptions.ESavePoint.LastSolvePointFile);
1254 Assert.AreEqual(GAMSOptions.ESavePoint.LastSolvePointFile, globalOpt.SavePoint, "expect same options " + GAMSOptions.ESavePoint.LastSolvePointFile + " set");
1255
1256 globalOpt.SavePoint = (GAMSOptions.ESavePoint.EverySolvePointFile);
1257 Assert.AreEqual(GAMSOptions.ESavePoint.EverySolvePointFile, globalOpt.SavePoint, "expect same options " + GAMSOptions.ESavePoint.EverySolvePointFile + " set");
1258
1259 globalOpt.SavePoint = (GAMSOptions.ESavePoint.LastSolvePointFileScrDir);
1260 Assert.AreEqual(GAMSOptions.ESavePoint.LastSolvePointFileScrDir, globalOpt.SavePoint, "expect same options " + GAMSOptions.ESavePoint.LastSolvePointFileScrDir + " set");
1261
1262 globalOpt.SavePoint = (GAMSOptions.ESavePoint.EverySolvePointFileScrDir);
1263 Assert.AreEqual(GAMSOptions.ESavePoint.EverySolvePointFileScrDir, globalOpt.SavePoint, "expect same options " + GAMSOptions.ESavePoint.EverySolvePointFileScrDir + " set");
1264
1265 logger.Debug("Exiting TestGAMSOptions | testEnumSavePoint");
1266 }
1267
1268 //[Test]
1269 //public void TestLookupEnumSavePoint()
1270 //{
1271 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSavePoint");
1272
1273 // Assert.AreEqual("Lookup NoPointFile from ESavePoint", GAMSOptions.ESavePoint.NoPointFile, GAMSOptions.ESavePoint.lookup(0));
1274 // Assert.AreEqual("Lookup LastSolvePointFile from ESavePoint", GAMSOptions.ESavePoint.LastSolvePointFile, GAMSOptions.ESavePoint.lookup(1));
1275 // Assert.AreEqual("Lookup EverySolvePointFile from ESavePoint", GAMSOptions.ESavePoint.EverySolvePointFile, GAMSOptions.ESavePoint.lookup(2));
1276 // Assert.AreEqual("Lookup LastSolvePointFileScrDir from ESavePoint", GAMSOptions.ESavePoint.LastSolvePointFileScrDir, GAMSOptions.ESavePoint.lookup(3));
1277 // Assert.AreEqual("Lookup EverySolvePointFileScrDir from ESavePoint", GAMSOptions.ESavePoint.EverySolvePointFileScrDir, GAMSOptions.ESavePoint.lookup(4));
1278
1279 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSavePoint");
1280 //}
1281
1282
1283 [Test]
1284 public void TestEnumShowOSMemory()
1285 {
1286 logger.Debug("Entering TestGAMSOptions | testEnumShowOSMemory");
1287
1288 globalOpt.ShowOSMemory = (GAMSOptions.EShowOSMemory.InternalAccounting);
1289 Assert.AreEqual(GAMSOptions.EShowOSMemory.InternalAccounting, globalOpt.ShowOSMemory, "expect same options " + GAMSOptions.EShowOSMemory.InternalAccounting + " set");
1290
1291 globalOpt.ShowOSMemory = (GAMSOptions.EShowOSMemory.RSS);
1292 Assert.AreEqual(GAMSOptions.EShowOSMemory.RSS, globalOpt.ShowOSMemory, "expect same options " + GAMSOptions.EShowOSMemory.RSS + " set");
1293
1294 globalOpt.ShowOSMemory = (GAMSOptions.EShowOSMemory.VSS);
1295 Assert.AreEqual(GAMSOptions.EShowOSMemory.VSS, globalOpt.ShowOSMemory, "expect same options " + GAMSOptions.EShowOSMemory.VSS + " set");
1296
1297 logger.Debug("Exiting TestGAMSOptions | testEnumShowOSMemory");
1298 }
1299
1300 //[Test]
1301 //public void TestLookupEnumShowOSMemory()
1302 //{
1303 // logger.Debug("Entering TestGAMSOptions | testLookupEnumShowOSMemory");
1304
1305 // Assert.AreEqual("Lookup InternalAccounting from EShowOSMemory", GAMSOptions.EShowOSMemory.InternalAccounting, GAMSOptions.EShowOSMemory.lookup(0));
1306 // Assert.AreEqual("Lookup RSS from EShowOSMemory", GAMSOptions.EShowOSMemory.RSS, GAMSOptions.EShowOSMemory.lookup(1));
1307 // Assert.AreEqual("Lookup VSS from EShowOSMemory", GAMSOptions.EShowOSMemory.VSS, GAMSOptions.EShowOSMemory.lookup(2));
1308
1309 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumShowOSMemory");
1310 //}
1311
1312
1313 [Test]
1314 public void TestEnumSolPrint()
1315 {
1316 logger.Debug("Entering TestGAMSOptions | testEnumSolPrint");
1317
1318 globalOpt.SolPrint = (GAMSOptions.ESolPrint.RemoveSolLstFollowingSolves);
1319 Assert.AreEqual(GAMSOptions.ESolPrint.RemoveSolLstFollowingSolves, globalOpt.SolPrint, "expect same options " + GAMSOptions.ESolPrint.RemoveSolLstFollowingSolves + " set");
1320
1321 globalOpt.SolPrint = (GAMSOptions.ESolPrint.IncludeSolLstFollowingSolves);
1322 Assert.AreEqual(GAMSOptions.ESolPrint.IncludeSolLstFollowingSolves, globalOpt.SolPrint, "expect same options " + GAMSOptions.ESolPrint.IncludeSolLstFollowingSolves + " set");
1323
1324 globalOpt.SolPrint = (GAMSOptions.ESolPrint.SuppressAllSolInfo);
1325 Assert.AreEqual(GAMSOptions.ESolPrint.SuppressAllSolInfo, globalOpt.SolPrint, "expect same options " + GAMSOptions.ESolPrint.SuppressAllSolInfo + " set");
1326
1327 logger.Debug("Exiting TestGAMSOptions | testEnumSolPrint");
1328 }
1329
1330 //[Test]
1331 //public void TestLookupEnumSolPrint()
1332 //{
1333 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSolPrint");
1334
1335 // Assert.AreEqual("Lookup RemoveSolLstFollowingSolves from ESolPrint", GAMSOptions.ESolPrint.RemoveSolLstFollowingSolves, GAMSOptions.ESolPrint.lookup(0));
1336 // Assert.AreEqual("Lookup IncludeSolLstFollowingSolves from ESolPrint", GAMSOptions.ESolPrint.IncludeSolLstFollowingSolves, GAMSOptions.ESolPrint.lookup(1));
1337 // Assert.AreEqual("Lookup SuppressAllSolInfo from ESolPrint", GAMSOptions.ESolPrint.SuppressAllSolInfo, GAMSOptions.ESolPrint.lookup(2));
1338
1339 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSolPrint");
1340 //}
1341
1342
1343 [Test]
1344 public void TestEnumSolveLink()
1345 {
1346 logger.Debug("Entering TestGAMSOptions | testEnumSolveLink");
1347
1348 globalOpt.SolveLink = (GAMSOptions.ESolveLink.ChainScript);
1349 Assert.AreEqual(GAMSOptions.ESolveLink.ChainScript, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.ChainScript + " set");
1350
1351 globalOpt.SolveLink = (GAMSOptions.ESolveLink.CallScript);
1352 Assert.AreEqual(GAMSOptions.ESolveLink.CallScript, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.CallScript + " set");
1353
1354 globalOpt.SolveLink = (GAMSOptions.ESolveLink.CallModule);
1355 Assert.AreEqual(GAMSOptions.ESolveLink.CallModule, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.CallModule + " set");
1356
1357 globalOpt.SolveLink = (GAMSOptions.ESolveLink.AsyncGrid);
1358 Assert.AreEqual(GAMSOptions.ESolveLink.AsyncGrid, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.AsyncGrid + " set");
1359
1360 globalOpt.SolveLink = (GAMSOptions.ESolveLink.AsyncSimulate);
1361 Assert.AreEqual(GAMSOptions.ESolveLink.AsyncSimulate, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.AsyncSimulate + " set");
1362
1363 globalOpt.SolveLink = (GAMSOptions.ESolveLink.LoadLibrary);
1364 Assert.AreEqual(GAMSOptions.ESolveLink.LoadLibrary, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.LoadLibrary + " set");
1365
1366 globalOpt.SolveLink = (GAMSOptions.ESolveLink.LoadLibraryAsync);
1367 Assert.AreEqual(GAMSOptions.ESolveLink.LoadLibraryAsync, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.LoadLibraryAsync + " set");
1368
1369 globalOpt.SolveLink = (GAMSOptions.ESolveLink.LoadLibraryAsyncSimulate);
1370 Assert.AreEqual(GAMSOptions.ESolveLink.LoadLibraryAsyncSimulate, globalOpt.SolveLink, "expect same options " + GAMSOptions.ESolveLink.LoadLibraryAsyncSimulate + " set");
1371
1372 logger.Debug("Exiting TestGAMSOptions | testEnumSolveLink");
1373 }
1374
1375 //[Test]
1376 //public void TestLookupEnumSolveLink()
1377 //{
1378 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSolveLink");
1379
1380 // Assert.AreEqual("Lookup ChainScript from ESolveLink", GAMSOptions.ESolveLink.ChainScript, GAMSOptions.ESolveLink.lookup(0));
1381 // Assert.AreEqual("Lookup CallScript from ESolveLink", GAMSOptions.ESolveLink.CallScript, GAMSOptions.ESolveLink.lookup(1));
1382 // Assert.AreEqual("Lookup CallModule from ESolveLink", GAMSOptions.ESolveLink.CallModule, GAMSOptions.ESolveLink.lookup(2));
1383 // Assert.AreEqual("Lookup AsyncGrid from ESolveLink", GAMSOptions.ESolveLink.AsyncGrid, GAMSOptions.ESolveLink.lookup(3));
1384 // Assert.AreEqual("Lookup AsyncSimulate from ESolveLink", GAMSOptions.ESolveLink.AsyncSimulate, GAMSOptions.ESolveLink.lookup(4));
1385 // Assert.AreEqual("Lookup LoadLibrary from ESolveLink", GAMSOptions.ESolveLink.LoadLibrary, GAMSOptions.ESolveLink.lookup(5));
1386 // Assert.AreEqual("Lookup LoadLibraryAsync from ESolveLink", GAMSOptions.ESolveLink.LoadLibraryAsync, GAMSOptions.ESolveLink.lookup(6));
1387 // Assert.AreEqual("Lookup LoadLibraryAsyncSimulate from ESolveLink", GAMSOptions.ESolveLink.LoadLibraryAsyncSimulate, GAMSOptions.ESolveLink.lookup(7));
1388
1389 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSolveLink");
1390 //}
1391
1392
1393 [Test]
1394 public void TestEnumStepSum()
1395 {
1396 logger.Debug("Entering TestGAMSOptions | testEnumStepSum");
1397
1398 globalOpt.StepSum = (GAMSOptions.EStepSum.NoStepSummmary);
1399 Assert.AreEqual(GAMSOptions.EStepSum.NoStepSummmary, globalOpt.StepSum, "expect same options " + GAMSOptions.EStepSum.NoStepSummmary + " set");
1400
1401 globalOpt.StepSum = (GAMSOptions.EStepSum.StepSummary);
1402 Assert.AreEqual(GAMSOptions.EStepSum.StepSummary, globalOpt.StepSum, "expect same options " + GAMSOptions.EStepSum.StepSummary + " set");
1403
1404 logger.Debug("Exiting TestGAMSOptions | testEnumStepSum");
1405 }
1406
1407 //[Test]
1408 //public void TestLookupEnumStepSum()
1409 //{
1410 // logger.Debug("Entering TestGAMSOptions | testLookupEnumStepSum");
1411
1412 // Assert.AreEqual("Lookup NoStepSummmary from EStepSum", GAMSOptions.EStepSum.NoStepSummmary, GAMSOptions.EStepSum.lookup(0));
1413 // Assert.AreEqual("Lookup StepSummary from EStepSum", GAMSOptions.EStepSum.StepSummary, GAMSOptions.EStepSum.lookup(1));
1414
1415 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumStepSum");
1416 //}
1417
1418
1419 [Test]
1420 public void TestEnumstrictSingleton()
1421 {
1422 logger.Debug("Entering TestGAMSOptions | testEnumstrictSingleton");
1423
1424 globalOpt.strictSingleton = (GAMSOptions.EstrictSingleton.FirstRecord);
1425 Assert.AreEqual(GAMSOptions.EstrictSingleton.FirstRecord, globalOpt.strictSingleton, "expect same options " + GAMSOptions.EstrictSingleton.FirstRecord + " set");
1426
1427 globalOpt.strictSingleton = (GAMSOptions.EstrictSingleton.Error);
1428 Assert.AreEqual(GAMSOptions.EstrictSingleton.Error, globalOpt.strictSingleton, "expect same options " + GAMSOptions.EstrictSingleton.Error + " set");
1429
1430 logger.Debug("Exiting TestGAMSOptions | testEnumstrictSingleton");
1431 }
1432
1433 //[Test]
1434 //public void TestLookupEnumstrictSingleton()
1435 //{
1436 // logger.Debug("Entering TestGAMSOptions | testLookupEnumstrictSingleton");
1437
1438 // Assert.AreEqual("Lookup FirstRecord from EstrictSingleton", GAMSOptions.EstrictSingleton.FirstRecord, GAMSOptions.EstrictSingleton.lookup(0));
1439 // Assert.AreEqual("Lookup Error from EstrictSingleton", GAMSOptions.EstrictSingleton.Error, GAMSOptions.EstrictSingleton.lookup(1));
1440
1441 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumstrictSingleton");
1442 //}
1443
1444
1445 [Test]
1446 public void TestEnumStringChk()
1447 {
1448 logger.Debug("Entering TestGAMSOptions | testEnumStringChk");
1449
1450 globalOpt.StringChk = (GAMSOptions.EStringChk.NoError);
1451 Assert.AreEqual(GAMSOptions.EStringChk.NoError, globalOpt.StringChk, "expect same options " + GAMSOptions.EStringChk.NoError + " set");
1452
1453 globalOpt.StringChk = (GAMSOptions.EStringChk.Error);
1454 Assert.AreEqual(GAMSOptions.EStringChk.Error, globalOpt.StringChk, "expect same options " + GAMSOptions.EStringChk.Error + " set");
1455
1456 globalOpt.StringChk = (GAMSOptions.EStringChk.NoErrorRemoveSymbol);
1457 Assert.AreEqual(GAMSOptions.EStringChk.NoErrorRemoveSymbol, globalOpt.StringChk, "expect same options " + GAMSOptions.EStringChk.NoErrorRemoveSymbol + " set");
1458
1459 logger.Debug("Exiting TestGAMSOptions | testEnumStringChk");
1460 }
1461
1462 //[Test]
1463 //public void TestLookupEnumStringChk()
1464 //{
1465 // logger.Debug("Entering TestGAMSOptions | testLookupEnumStringChk");
1466
1467 // Assert.AreEqual("Lookup NoError from EStringChk", GAMSOptions.EStringChk.NoError, GAMSOptions.EStringChk.lookup(0));
1468 // Assert.AreEqual("Lookup Error from EStringChk", GAMSOptions.EStringChk.Error, GAMSOptions.EStringChk.lookup(1));
1469 // Assert.AreEqual("Lookup NoErrorRemoveSymbol from EStringChk", GAMSOptions.EStringChk.NoErrorRemoveSymbol, GAMSOptions.EStringChk.lookup(2));
1470
1471 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumStringChk");
1472 //}
1473
1474
1475 [Test]
1476 public void TestEnumSuffixDLVars()
1477 {
1478 logger.Debug("Entering TestGAMSOptions | testEnumSuffixDLVars");
1479
1480 globalOpt.SuffixDLVars = (GAMSOptions.ESuffixDLVars.OffSuffixDLVars);
1481 Assert.AreEqual(GAMSOptions.ESuffixDLVars.OffSuffixDLVars, globalOpt.SuffixDLVars, "expect same options " + GAMSOptions.ESuffixDLVars.OffSuffixDLVars + " set");
1482
1483 globalOpt.SuffixDLVars = (GAMSOptions.ESuffixDLVars.OnSuffixDLVars);
1484 Assert.AreEqual(GAMSOptions.ESuffixDLVars.OnSuffixDLVars, globalOpt.SuffixDLVars, "expect same options " + GAMSOptions.ESuffixDLVars.OnSuffixDLVars + " set");
1485
1486 logger.Debug("Exiting TestGAMSOptions | testEnumSuffixDLVars");
1487 }
1488
1489 //[Test]
1490 //public void TestLookupEnumSuffixDLVars()
1491 //{
1492 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSuffixDLVars");
1493
1494 // Assert.AreEqual("Lookup off from ESuffixDLVars", GAMSOptions.ESuffixDLVars.OffSuffixDLVars, GAMSOptions.ESuffixDLVars.lookup("off"));
1495 // Assert.AreEqual("Lookup on from ESuffixDLVars", GAMSOptions.ESuffixDLVars.OnSuffixDLVars, GAMSOptions.ESuffixDLVars.lookup("on"));
1496
1497 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSuffixDLVars");
1498 //}
1499
1500
1501 [Test]
1502 public void TestEnumSuffixAlgebraVars()
1503 {
1504 logger.Debug("Entering TestGAMSOptions | testEnumSuffixAlgebraVars");
1505
1506 globalOpt.SuffixAlgebraVars = (GAMSOptions.ESuffixAlgebraVars.OffSuffixAlgebraVars);
1507 Assert.AreEqual(GAMSOptions.ESuffixAlgebraVars.OffSuffixAlgebraVars, globalOpt.SuffixAlgebraVars, "expect same options " + GAMSOptions.ESuffixAlgebraVars.OffSuffixAlgebraVars + " set");
1508
1509 globalOpt.SuffixAlgebraVars = (GAMSOptions.ESuffixAlgebraVars.OnSuffixAlgebraVars);
1510 Assert.AreEqual(GAMSOptions.ESuffixAlgebraVars.OnSuffixAlgebraVars, globalOpt.SuffixAlgebraVars, "expect same options " + GAMSOptions.ESuffixAlgebraVars.OnSuffixAlgebraVars + " set");
1511
1512 logger.Debug("Exiting TestGAMSOptions | testEnumSuffixAlgebraVars");
1513 }
1514
1515 //[Test]
1516 //public void TestLookupEnumSuffixAlgebraVars()
1517 //{
1518 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSuffixAlgebraVars");
1519
1520 // Assert.AreEqual("Lookup off from ESuffixAlgebraVars", GAMSOptions.ESuffixAlgebraVars.OffSuffixAlgebraVars, GAMSOptions.ESuffixAlgebraVars.lookup("off"));
1521 // Assert.AreEqual("Lookup on from ESuffixAlgebraVars", GAMSOptions.ESuffixAlgebraVars.OnSuffixAlgebraVars, GAMSOptions.ESuffixAlgebraVars.lookup("on"));
1522
1523 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSuffixAlgebraVars");
1524 //}
1525
1526
1527 [Test]
1528 public void TestEnumSuppress()
1529 {
1530 logger.Debug("Entering TestGAMSOptions | testEnumSuppress");
1531
1532 globalOpt.Suppress = (GAMSOptions.ESuppress.StandardCompilerListing);
1533 Assert.AreEqual(GAMSOptions.ESuppress.StandardCompilerListing, globalOpt.Suppress, "expect same options " + GAMSOptions.ESuppress.StandardCompilerListing + " set");
1534
1535 globalOpt.Suppress = (GAMSOptions.ESuppress.SuppressCompilerListing);
1536 Assert.AreEqual(GAMSOptions.ESuppress.SuppressCompilerListing, globalOpt.Suppress, "expect same options " + GAMSOptions.ESuppress.SuppressCompilerListing + " set");
1537
1538 logger.Debug("Exiting TestGAMSOptions | testEnumSuppress");
1539 }
1540
1541 //[Test]
1542 //public void TestLookupEnumSuppress()
1543 //{
1544 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSuppress");
1545
1546 // Assert.AreEqual("Lookup StandardCompilerListing from ESuppress", GAMSOptions.ESuppress.StandardCompilerListing, GAMSOptions.ESuppress.lookup(0));
1547 // Assert.AreEqual("Lookup SuppressCompilerListing from ESuppress", GAMSOptions.ESuppress.SuppressCompilerListing, GAMSOptions.ESuppress.lookup(1));
1548
1549 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSuppress");
1550 //}
1551
1552
1553 [Test]
1554 public void TestEnumSys10()
1555 {
1556 logger.Debug("Entering TestGAMSOptions | testEnumSys10");
1557
1558 globalOpt.Sys10 = (GAMSOptions.ESys10.Disable);
1559 Assert.AreEqual(GAMSOptions.ESys10.Disable, globalOpt.Sys10, "expect same options " + GAMSOptions.ESys10.Disable + " set");
1560
1561 globalOpt.Sys10 = (GAMSOptions.ESys10.Enable);
1562 Assert.AreEqual(GAMSOptions.ESys10.Enable, globalOpt.Sys10, "expect same options " + GAMSOptions.ESys10.Enable + " set");
1563
1564 logger.Debug("Exiting TestGAMSOptions | testEnumSys10");
1565 }
1566
1567 //[Test]
1568 //public void TestLookupEnumSys10()
1569 //{
1570 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSys10");
1571
1572 // Assert.AreEqual("Lookup Disable from ESys10", GAMSOptions.ESys10.Disable, GAMSOptions.ESys10.lookup(0));
1573 // Assert.AreEqual("Lookup Enable from ESys10", GAMSOptions.ESys10.Enable, GAMSOptions.ESys10.lookup(1));
1574
1575 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSys10");
1576 //}
1577
1578
1579 [Test]
1580 public void TestEnumSys11()
1581 {
1582 logger.Debug("Entering TestGAMSOptions | testEnumSys11");
1583
1584 globalOpt.Sys11 = (GAMSOptions.ESys11.AutomaticOptimization);
1585 Assert.AreEqual(GAMSOptions.ESys11.AutomaticOptimization, globalOpt.Sys11, "expect same options " + GAMSOptions.ESys11.AutomaticOptimization + " set");
1586
1587 globalOpt.Sys11 = (GAMSOptions.ESys11.NoOptimization);
1588 Assert.AreEqual(GAMSOptions.ESys11.NoOptimization, globalOpt.Sys11, "expect same options " + GAMSOptions.ESys11.NoOptimization + " set");
1589
1590 globalOpt.Sys11 = (GAMSOptions.ESys11.AlwaysOptimize);
1591 Assert.AreEqual(GAMSOptions.ESys11.AlwaysOptimize, globalOpt.Sys11, "expect same options " + GAMSOptions.ESys11.AlwaysOptimize + " set");
1592
1593 logger.Debug("Exiting TestGAMSOptions | testEnumSys11");
1594 }
1595
1596 //[Test]
1597 //public void TestLookupEnumSys11()
1598 //{
1599 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSys11");
1600
1601 // Assert.AreEqual("Lookup AutomaticOptimization from ESys11", GAMSOptions.ESys11.AutomaticOptimization, GAMSOptions.ESys11.lookup(0));
1602 // Assert.AreEqual("Lookup NoOptimization from ESys11", GAMSOptions.ESys11.NoOptimization, GAMSOptions.ESys11.lookup(1));
1603 // Assert.AreEqual("Lookup AlwaysOptimize from ESys11", GAMSOptions.ESys11.AlwaysOptimize, GAMSOptions.ESys11.lookup(2));
1604
1605 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSys11");
1606 //}
1607
1608
1609 [Test]
1610 public void TestEnumSysOut()
1611 {
1612 logger.Debug("Entering TestGAMSOptions | testEnumSysOut");
1613
1614 globalOpt.SysOut = (GAMSOptions.ESysOut.SuppressAdditionalSolverOutput);
1615 Assert.AreEqual(GAMSOptions.ESysOut.SuppressAdditionalSolverOutput, globalOpt.SysOut, "expect same options " + GAMSOptions.ESysOut.SuppressAdditionalSolverOutput + " set");
1616
1617 globalOpt.SysOut = (GAMSOptions.ESysOut.IncludeAdditionalSolverOutput);
1618 Assert.AreEqual(GAMSOptions.ESysOut.IncludeAdditionalSolverOutput, globalOpt.SysOut, "expect same options " + GAMSOptions.ESysOut.IncludeAdditionalSolverOutput + " set");
1619
1620 logger.Debug("Exiting TestGAMSOptions | testEnumSysOut");
1621 }
1622
1623 //[Test]
1624 //public void TestLookupEnumSysOut()
1625 //{
1626 // logger.Debug("Entering TestGAMSOptions | testLookupEnumSysOut");
1627
1628 // Assert.AreEqual("Lookup SuppressAdditionalSolverOutput from ESysOut", GAMSOptions.ESysOut.SuppressAdditionalSolverOutput, GAMSOptions.ESysOut.lookup(0));
1629 // Assert.AreEqual("Lookup IncludeAdditionalSolverOutput from ESysOut", GAMSOptions.ESysOut.IncludeAdditionalSolverOutput, GAMSOptions.ESysOut.lookup(1));
1630
1631 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumSysOut");
1632 //}
1633
1634
1635 [Test]
1636 public void TestEnumTFormat()
1637 {
1638 logger.Debug("Entering TestGAMSOptions | testEnumTFormat");
1639
1640 globalOpt.TFormat = (GAMSOptions.ETFormat.Colon);
1641 Assert.AreEqual(GAMSOptions.ETFormat.Colon, globalOpt.TFormat, "expect same options " + GAMSOptions.ETFormat.Colon + " set");
1642
1643 globalOpt.TFormat = (GAMSOptions.ETFormat.Dot);
1644 Assert.AreEqual(GAMSOptions.ETFormat.Dot, globalOpt.TFormat, "expect same options " + GAMSOptions.ETFormat.Dot + " set");
1645
1646 logger.Debug("Exiting TestGAMSOptions | testEnumTFormat");
1647 }
1648
1649 //[Test]
1650 //public void TestLookupEnumTFormat()
1651 //{
1652 // logger.Debug("Entering TestGAMSOptions | testLookupEnumTFormat");
1653
1654 // Assert.AreEqual("Lookup Colon from ETFormat", GAMSOptions.ETFormat.Colon, GAMSOptions.ETFormat.lookup(0));
1655 // Assert.AreEqual("Lookup Dot from ETFormat", GAMSOptions.ETFormat.Dot, GAMSOptions.ETFormat.lookup(1));
1656
1657 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumTFormat");
1658 //}
1659
1660
1661 [Test]
1662 public void TestEnumTraceOpt()
1663 {
1664 logger.Debug("Entering TestGAMSOptions | testEnumTraceOpt");
1665
1666 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.SolverAndGAMSStepTraceWOHeaders);
1667 Assert.AreEqual(GAMSOptions.ETraceOpt.SolverAndGAMSStepTraceWOHeaders, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.SolverAndGAMSStepTraceWOHeaders + " set");
1668
1669 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.SolverAndGAMSStepTrace);
1670 Assert.AreEqual(GAMSOptions.ETraceOpt.SolverAndGAMSStepTrace, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.SolverAndGAMSStepTrace + " set");
1671
1672 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.SolverStepTraceOnly);
1673 Assert.AreEqual(GAMSOptions.ETraceOpt.SolverStepTraceOnly, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.SolverStepTraceOnly + " set");
1674
1675 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.TraceFileFormatGAMSPerformanceWorld);
1676 Assert.AreEqual(GAMSOptions.ETraceOpt.TraceFileFormatGAMSPerformanceWorld, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.TraceFileFormatGAMSPerformanceWorld + " set");
1677
1678 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.TraceFileFormatSupportingNLPEC);
1679 Assert.AreEqual(GAMSOptions.ETraceOpt.TraceFileFormatSupportingNLPEC, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.TraceFileFormatSupportingNLPEC + " set");
1680
1681 globalOpt.TraceOpt = (GAMSOptions.ETraceOpt.TraceFileWithAllAvailableTraceFields);
1682 Assert.AreEqual(GAMSOptions.ETraceOpt.TraceFileWithAllAvailableTraceFields, globalOpt.TraceOpt, "expect same options " + GAMSOptions.ETraceOpt.TraceFileWithAllAvailableTraceFields + " set");
1683
1684 logger.Debug("Exiting TestGAMSOptions | testEnumTraceOpt");
1685 }
1686
1687 //[Test]
1688 //public void TestLookupEnumTraceOpt()
1689 //{
1690 // logger.Debug("Entering TestGAMSOptions | testLookupEnumTraceOpt");
1691
1692 // Assert.AreEqual("Lookup SolverAndGAMSStepTraceWOHeaders from ETraceOpt", GAMSOptions.ETraceOpt.SolverAndGAMSStepTraceWOHeaders, GAMSOptions.ETraceOpt.lookup(0));
1693 // Assert.AreEqual("Lookup SolverAndGAMSStepTrace from ETraceOpt", GAMSOptions.ETraceOpt.SolverAndGAMSStepTrace, GAMSOptions.ETraceOpt.lookup(1));
1694 // Assert.AreEqual("Lookup SolverStepTraceOnly from ETraceOpt", GAMSOptions.ETraceOpt.SolverStepTraceOnly, GAMSOptions.ETraceOpt.lookup(2));
1695 // Assert.AreEqual("Lookup TraceFileFormatGAMSPerformanceWorld from ETraceOpt", GAMSOptions.ETraceOpt.TraceFileFormatGAMSPerformanceWorld, GAMSOptions.ETraceOpt.lookup(3));
1696 // Assert.AreEqual("Lookup TraceFileFormatSupportingNLPEC from ETraceOpt", GAMSOptions.ETraceOpt.TraceFileFormatSupportingNLPEC, GAMSOptions.ETraceOpt.lookup(4));
1697 // Assert.AreEqual("Lookup TraceFileWithAllAvailableTraceFields from ETraceOpt", GAMSOptions.ETraceOpt.TraceFileWithAllAvailableTraceFields, GAMSOptions.ETraceOpt.lookup(5));
1698
1699 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumTraceOpt");
1700 //}
1701
1702
1703 [Test]
1704 public void TestEnumZeroResRep()
1705 {
1706 logger.Debug("Entering TestGAMSOptions | testEnumZeroResRep");
1707
1708 globalOpt.ZeroResRep = (GAMSOptions.EZeroResRep.NoWarning);
1709 Assert.AreEqual(GAMSOptions.EZeroResRep.NoWarning, globalOpt.ZeroResRep, "expect same options " + GAMSOptions.EZeroResRep.NoWarning + " set");
1710
1711 globalOpt.ZeroResRep = (GAMSOptions.EZeroResRep.IssueWarning);
1712 Assert.AreEqual(GAMSOptions.EZeroResRep.IssueWarning, globalOpt.ZeroResRep, "expect same options " + GAMSOptions.EZeroResRep.IssueWarning + " set");
1713
1714 logger.Debug("Exiting TestGAMSOptions | testEnumZeroResRep");
1715 }
1716
1717 //[Test]
1718 //public void TestLookupEnumZeroResRep()
1719 //{
1720 // logger.Debug("Entering TestGAMSOptions | testLookupEnumZeroResRep");
1721
1722 // Assert.AreEqual("Lookup NoWarning from EZeroResRep", GAMSOptions.EZeroResRep.NoWarning, GAMSOptions.EZeroResRep.lookup(0));
1723 // Assert.AreEqual("Lookup IssueWarning from EZeroResRep", GAMSOptions.EZeroResRep.IssueWarning, GAMSOptions.EZeroResRep.lookup(1));
1724
1725 // logger.Debug("Exiting TestGAMSOptions | testLookupEnumZeroResRep");
1726 //}
1727
1728
1729
1730 }
1731}
EgdxConvert gdxConvert
EIntVarUp IntVarUp
ETraceOpt TraceOpt
EFreeEmbeddedPython FreeEmbeddedPython
EPrefixLoadPath PrefixLoadPath
EAppendOut AppendOut
EECImplicitLoad ECImplicitLoad
EHoldFixed HoldFixed
EStringChk StringChk
EZeroResRep ZeroResRep
ENoNewVarEqu NoNewVarEqu
ELstTitleLeftAligned LstTitleLeftAligned
EFiltered Filtered
ESavePoint SavePoint
EPreviousWork PreviousWork
EPageContr PageContr
EInteractiveSolver InteractiveSolver
ESolPrint SolPrint
EForceWork ForceWork
ESuffixDLVars SuffixDLVars
EReferenceLineNo ReferenceLineNo
ESuppress Suppress
EgdxCompress gdxCompress
EFileCase FileCase
EstrictSingleton strictSingleton
EProcTreeMemMonitor ProcTreeMemMonitor
EExecMode ExecMode
EAsyncSolLst AsyncSolLst
ESuffixAlgebraVars SuffixAlgebraVars
EShowOSMemory ShowOSMemory
EAppendExpand AppendExpand
ECheckErrorLevel CheckErrorLevel
ESolveLink SolveLink
EDumpParms DumpParms
ECaptureModelInstance CaptureModelInstance
EHoldFixedAsync HoldFixedAsync
GAMSOptions AddOptions(GAMSOptions optFrom=null)
static void initializeTestFrom(String filename, String subdir)
initialize class properties from fileName and prepare directory subdir
Definition: HouseKeeper.cs:114