OpenMPCD
test_Configuration.py
1 from MPCDAnalysis.Configuration import Configuration
2 
3 def test_various():
4  config = Configuration("""
5  str = "hello world";
6  int = 123;
7  float = -4.56;
8  group =
9  {
10  str = "foobar";
11  int = -789;
12  float = -10.0;
13  group =
14  {
15  str = "level3";
16  };
17  };
18 
19  list = (0, 1, 2, 3);
20 
21  listOfGroups =
22  (
23  {
24  name = "group1";
25  },
26  {
27  name = "group2";
28  isGroup2 = true;
29  }
30  );
31  """)
32 
33  assert config["str"] == "hello world"
34  assert config["int"] == 123
35  assert config["group.str"] == "foobar"
36  assert config["group"]["float"] == -10.0
37  assert config["listOfGroups"]["[1].isGroup2"] == True
38 
39  config["str"] = "newvalue"
40  config["group.str"] = "barfoo"
41  config["listOfGroups"]["[1].isGroup2"] = False
42  config["newsetting"] = "hello"
43  config["newgroup.setting"] = 777
44  assert config["str"] == "newvalue"
45  assert config["group"]["str"] == "barfoo"
46  assert config["listOfGroups"]["[1]"]["isGroup2"] == False
47  assert config["listOfGroups"]["[1].isGroup2"] == False
48  assert config["newsetting"] == "hello"
49  assert config["newgroup.setting"] == 777
50 
51  assert "str" in config
52  assert "int" in config
53  assert "group" in config
54  assert "group.str" in config
55  assert "float" in config["group"]
56  assert "group.group" in config
57  assert "group.group.str" in config
58  assert "foobar" not in config
59  assert "list" in config
60  assert "list.[0]" in config
61  assert "[0]" in config["list"]
62  assert "[4]" not in config["list"]
63  assert "list.[4]" not in config
64  assert "listOfGroups.[0].name" in config
65  assert "[1]" in config["listOfGroups"]
66  assert "name" in config["listOfGroups.[0]"]
67  assert "listOfGroups.[1].name" in config
68  assert "listOfGroups.[2].name" not in config
69 
70  assert "newgroup2" not in config
71  newgroup2 = config.createGroup("newgroup2")
72  config.createGroup("newgroup2.asdf.foo")
73  newgroup2.createGroup("sub")
74  newgroup2.createGroup("sub")
75  assert "newgroup2" in config
76  assert "newgroup2.asdf.foo" in config
77  assert "newgroup2.sub" in config
78  assert "sub" in config["newgroup2"]
79  assert "sub" in newgroup2
80 
81  del config["newgroup2.asdf.foo"]
82  assert "newgroup2.asdf.foo" not in config
83  del config["newgroup2"]
84  assert "newgroup2" not in config
85 
86 
87  import copy
88 
89  assert config.isEquivalent(config)
90  copiedConfig = copy.deepcopy(config)
91  assert config.isEquivalent(copiedConfig)
92  assert copiedConfig.isEquivalent(config)
93  del config["newgroup.setting"]
94  assert not config.isEquivalent(copiedConfig)
95  assert not copiedConfig.isEquivalent(config)
96 
97  copiedConfig = copy.deepcopy(config)
98  assert config.isEquivalent(copiedConfig)
99  assert copiedConfig.isEquivalent(config)
100  del config["newgroup"]
101  assert not config.isEquivalent(copiedConfig)
102  assert not copiedConfig.isEquivalent(config)
103 
104  copiedConfig = copy.deepcopy(config)
105  del config["newsetting"]
106  assert not config.isEquivalent(copiedConfig)
107  assert not copiedConfig.isEquivalent(config)
108 
109 
110  config = Configuration("foo: [1, 2, 3]")
111  assert "foo" in config
112  assert "foo.[0]" in config
113  assert "[0]" in config["foo"]
114  assert config["foo.[0]"] == 1
115  assert config["foo.[1]"] == 2
116  assert config["foo.[2]"] == 3
117  config["foo.[0]"] = 4
118  assert config["foo.[0]"] == 4
119  assert config["foo.[1]"] == 2
120  assert config["foo.[2]"] == 3
121  assert config.isEquivalent(config)
122 
123 
124 def test_canonicalizing_constructor__LeesEdwards():
125  configString = \
126  """
127  group =
128  {
129  float = -10.0;
130  group =
131  {
132  str = "level3";
133  };
134  };
135 
136  boundaryConditions:
137  {
138  type = "Lees-Edwards"
139  shearRate = 0.123
140  }
141 
142  list = (0, 1, 2, 3);
143  """
144 
145 
146  configNotCanonicalized = Configuration(configString, False)
147  configCanonicalized = Configuration(configString)
148 
149  assert "boundaryConditions" in configNotCanonicalized
150  assert "boundaryConditions" in configCanonicalized
151 
152 
153  assert "boundaryConditions.type" in configNotCanonicalized
154  assert configNotCanonicalized["boundaryConditions.type"] == "Lees-Edwards"
155  assert not "boundaryConditions.type" in configCanonicalized
156 
157  assert "type" in configNotCanonicalized["boundaryConditions"]
158  assert \
159  configNotCanonicalized["boundaryConditions"]["type"] == "Lees-Edwards"
160  assert not "type" in configCanonicalized["boundaryConditions"]
161 
162 
163  assert "boundaryConditions.shearRate" in configNotCanonicalized
164  assert configNotCanonicalized["boundaryConditions.shearRate"] == 0.123
165  assert not "boundaryConditions.shearRate" in configCanonicalized
166 
167  assert "shearRate" in configNotCanonicalized["boundaryConditions"]
168  assert configNotCanonicalized["boundaryConditions"]["shearRate"] == 0.123
169  assert not "shearRate" in configCanonicalized["boundaryConditions"]
170 
171 
172  assert not "boundaryConditions.LeesEdwards" in configNotCanonicalized
173  assert "boundaryConditions.LeesEdwards" in configCanonicalized
174 
175  assert \
176  not "boundaryConditions.LeesEdwards.shearRate" in configNotCanonicalized
177  assert "boundaryConditions.LeesEdwards.shearRate" in configCanonicalized
178 
179  assert \
180  configCanonicalized["boundaryConditions.LeesEdwards.shearRate"] == 0.123
181  assert \
182  configCanonicalized["boundaryConditions"]["LeesEdwards"]["shearRate"] \
183  == 0.123
184 
185 
186 def test_canonicalizing_constructor__cellSubdivision():
187  configString = \
188  """
189  group =
190  {
191  float = -10.0;
192  group =
193  {
194  str = "level3";
195  };
196  };
197 
198  instrumentation:
199  {
200  cellSubdivision:
201  {
202  x = 5
203  y = 6
204  z = 7
205  }
206  }
207 
208  list = (0, 1, 2, 3);
209  """
210 
211 
212  configNotCanonicalized = Configuration(configString, False)
213  configCanonicalized = Configuration(configString)
214 
215  assert "instrumentation" in configNotCanonicalized
216  assert "instrumentation" in configCanonicalized
217 
218 
219  assert "instrumentation.cellSubdivision" in configNotCanonicalized
220  assert configNotCanonicalized["instrumentation.cellSubdivision.x"] == 5
221  assert configNotCanonicalized["instrumentation.cellSubdivision.y"] == 6
222  assert configNotCanonicalized["instrumentation.cellSubdivision.z"] == 7
223  assert not "instrumentation.cellSubdivision" in configCanonicalized
224 
225  assert "cellSubdivision" in configNotCanonicalized["instrumentation"]
226  assert configNotCanonicalized["instrumentation"]["cellSubdivision.x"] == 5
227  assert configNotCanonicalized["instrumentation"]["cellSubdivision.y"] == 6
228  assert configNotCanonicalized["instrumentation"]["cellSubdivision.z"] == 7
229  assert not "cellSubdivision" in configCanonicalized["instrumentation"]
230 
231 
232  assert not "instrumentation.flowProfile" in configNotCanonicalized
233  assert not "instrumentation.densityProfile" in configNotCanonicalized
234  assert "instrumentation.flowProfile" in configCanonicalized
235  assert "instrumentation.flowProfile.cellSubdivision" in configCanonicalized
236  assert "instrumentation.densityProfile" in configCanonicalized
237  assert \
238  "instrumentation.densityProfile.cellSubdivision" in configCanonicalized
239 
240  assert \
241  configCanonicalized["instrumentation.flowProfile.cellSubdivision.x"] \
242  == 5
243  assert \
244  configCanonicalized["instrumentation.flowProfile.cellSubdivision.y"] \
245  == 6
246  assert \
247  configCanonicalized["instrumentation.flowProfile.cellSubdivision.z"] \
248  == 7
249 
250  assert \
251  configCanonicalized["instrumentation"]["densityProfile"]\
252  ["cellSubdivision"]["x"] \
253  == 5
254  assert \
255  configCanonicalized["instrumentation"]["densityProfile"]\
256  ["cellSubdivision"]["y"] \
257  == 6
258  assert \
259  configCanonicalized["instrumentation"]["densityProfile"]\
260  ["cellSubdivision"]["z"] \
261  == 7
262 
263 
264 
265 
266 def test_isEquivalent():
267  config = Configuration("""
268  str = "hello world";
269  int = 123;
270  float = -4.56;
271  group =
272  {
273  str = "foobar";
274  int = -789;
275  float = -10.0;
276  group =
277  {
278  str = "level3";
279  };
280  };
281 
282  list = (0, 1, 2, 3);
283 
284  listOfGroups =
285  (
286  {
287  name = "group1";
288  },
289  {
290  name = "group2";
291  isGroup2 = true;
292  }
293  );
294  """)
295 
296  import pytest
297 
298  with pytest.raises(TypeError):
299  config.isEquivalent("string")
300  with pytest.raises(TypeError):
301  config.isEquivalent([config])
302  with pytest.raises(TypeError):
303  config.isEquivalent(config, (lambda x: x))
304  with pytest.raises(TypeError):
305  config.isEquivalent(config, [lambda x: x, "hi"])
306 
307  config["newsetting"] = "hello"
308  config["newgroup.setting"] = 777
309 
310  import copy
311 
312  assert config.isEquivalent(config)
313  copiedConfig = copy.deepcopy(config)
314  assert config.isEquivalent(copiedConfig)
315  assert copiedConfig.isEquivalent(config)
316  del config["newgroup.setting"]
317  assert not config.isEquivalent(copiedConfig)
318  assert not copiedConfig.isEquivalent(config)
319 
320  copiedConfig = copy.deepcopy(config)
321  assert config.isEquivalent(copiedConfig)
322  assert copiedConfig.isEquivalent(config)
323  del config["newgroup"]
324  assert not config.isEquivalent(copiedConfig)
325  assert not copiedConfig.isEquivalent(config)
326 
327  copiedConfig = copy.deepcopy(config)
328  del config["newsetting"]
329  assert not config.isEquivalent(copiedConfig)
330  assert not copiedConfig.isEquivalent(config)
331 
332 
333  config = Configuration("foo: [1, 2, 3]")
334  config["foo.[0]"] = 4
335  assert config.isEquivalent(config)
336 
337 
338  configString = """
339  toplevel = "hello world"
340  group: { asdf = ["hi", "whatever"] }
341  arrayOfStrings: ["foo", "bar", "helium"]
342  arrayOfInts: [1, 2, 3]
343  listOfStrings: ("foo", "bar", "helium")
344  listOfInts: (1, 2, 3)
345  """
346 
347  translateX = lambda s: s.replace("h", "X")
348  translateY = lambda s: s.replace("w", "Y")
349  configStringReplaced = translateX(translateY(configString))
350  config = Configuration(configString)
351  configReplaced = Configuration(configStringReplaced)
352 
353  assert not config.isEquivalent(configReplaced)
354  assert not config.isEquivalent(configReplaced, [translateX])
355  assert not config.isEquivalent(configReplaced, [translateY])
356  assert config.isEquivalent(configReplaced, [translateX, translateY])
357 
358 
359 
360 def test_isEquivalent_array_list_vs_group():
361  l = Configuration("x = (5, 10)")
362  a = Configuration("x = [5, 10]")
363  g = Configuration("x = {f = 5; t = 10}")
364 
365  assert l.isEquivalent(l)
366  assert l.isEquivalent(a)
367  assert a.isEquivalent(a)
368  assert a.isEquivalent(l)
369  assert g.isEquivalent(g)
370 
371  assert not l.isEquivalent(g)
372  assert not a.isEquivalent(g)
373  assert not g.isEquivalent(l)
374  assert not g.isEquivalent(a)
375 
376 def test_isEquivalent_array_list_sizes():
377  listLong = Configuration("x = (2, 3, 4)")
378  listShort = Configuration("x = (2, 3)")
379 
380  arrayLong = Configuration("x = [2, 3, 4]")
381  arrayShort = Configuration("x = [2, 3]")
382 
383  longs = [listLong, arrayLong]
384  shorts = [listShort, arrayShort]
385 
386  for long in longs:
387  for otherLong in longs:
388  assert long.isEquivalent(otherLong)
389 
390  for short in shorts:
391  for otherShort in shorts:
392  assert short.isEquivalent(otherShort)
393 
394  for long in longs:
395  for short in shorts:
396  assert not long.isEquivalent(short)
397  assert not short.isEquivalent(long)
398 
399 
400 def test_isEquivalent_array_vs_list():
401  config1 = Configuration("x = (2, 3, 4)")
402  config2 = Configuration("x = [2, 3, 4]")
403  config3 = Configuration("something = 2")
404 
405  assert config1.isEquivalent(config1)
406  assert config2.isEquivalent(config2)
407 
408  assert not config1.isEquivalent(config3)
409  assert not config2.isEquivalent(config3)
410  assert not config3.isEquivalent(config1)
411  assert not config3.isEquivalent(config2)
412 
413  assert config1.isEquivalent(config2)
414  assert config2.isEquivalent(config1)
415 
416 
417 def test_getAsFlatDictionary():
418  config = Configuration("""
419  str = "hello world";
420  int = 123;
421  float = -4.56;
422  group =
423  {
424  str = "foobar";
425  int = -789;
426  float = -10.0;
427  group =
428  {
429  str = "level3";
430  };
431  };
432 
433  list = (0, 1, 2, 3);
434  array = [ -1.23, 4.56 ];
435 
436  listOfGroups =
437  (
438  {
439  name = "group1";
440  },
441  {
442  name = "group2";
443  isGroup2 = true;
444  },
445  {
446  }
447  );
448 
449  emptyGroup = {}
450  emptyArray = []
451  emptyList = ()
452  """)
453 
454  d = config.getAsFlatDictionary()
455 
456  assert isinstance(d, dict)
457 
458  expectedElementCount = 0
459 
460  assert "str" in d
461  assert d["str"] == "hello world"
462  expectedElementCount += 1
463 
464  assert "int" in d
465  assert d["int"] == 123
466  expectedElementCount += 1
467 
468  assert "float" in d
469  assert d["float"] == -4.56
470  expectedElementCount += 1
471 
472  assert "group.str" in d
473  assert d["group.str"] == "foobar"
474  expectedElementCount += 1
475 
476  assert "group.int" in d
477  assert d["group.int"] == -789
478  expectedElementCount += 1
479 
480  assert "group.float" in d
481  assert d["group.float"] == -10.0
482  expectedElementCount += 1
483 
484  assert "group.group.str" in d
485  assert d["group.group.str"] == "level3"
486  expectedElementCount += 1
487 
488  assert "list.[0]" in d
489  assert d["list.[0]"] == 0
490  expectedElementCount += 1
491 
492  assert "list.[1]" in d
493  assert d["list.[1]"] == 1
494  expectedElementCount += 1
495 
496  assert "list.[2]" in d
497  assert d["list.[2]"] == 2
498  expectedElementCount += 1
499 
500  assert "list.[3]" in d
501  assert d["list.[3]"] == 3
502  expectedElementCount += 1
503 
504  assert "array.[0]" in d
505  assert d["array.[0]"] == -1.23
506  expectedElementCount += 1
507 
508  assert "array.[1]" in d
509  assert d["array.[1]"] == 4.56
510  expectedElementCount += 1
511 
512  assert "listOfGroups.[0].name" in d
513  assert d["listOfGroups.[0].name"] == "group1"
514  expectedElementCount += 1
515 
516  assert "listOfGroups.[1].name" in d
517  assert d["listOfGroups.[1].name"] == "group2"
518  expectedElementCount += 1
519 
520  assert "listOfGroups.[1].name" in d
521  assert d["listOfGroups.[1].isGroup2"] == True
522  expectedElementCount += 1
523 
524  assert "listOfGroups.[2]" in d
525  assert d["listOfGroups.[2]"] is None
526  expectedElementCount += 1
527 
528  assert "emptyGroup" in d
529  assert d["emptyGroup"] == None
530  expectedElementCount += 1
531 
532  assert "emptyArray" in d
533  assert d["emptyArray"] == None
534  expectedElementCount += 1
535 
536  assert "emptyList" in d
537  assert d["emptyList"] == None
538  expectedElementCount += 1
539 
540  assert len(d) == expectedElementCount
541 
542 
543 def test_getDifferencesAsFlatDictionary_argumentType():
544  config = Configuration("foo = 1")
545  rasied = False
546  try:
547  config.getDifferencesAsFlatDictionary(3)
548  except TypeError:
549  raised = True
550  assert raised
551 
552 def test_getDifferencesAsFlatDictionary():
553  config1 = Configuration("""
554  str = "hello world";
555  int = 1234;
556  float = -4.56;
557  group =
558  {
559  str = "foobar";
560  int = -789;
561  float = -10.0;
562  group =
563  {
564  str = "level3";
565  };
566  };
567 
568  list = (0, 1, 2, 3);
569 
570  listOfGroups =
571  (
572  {
573  name = "group1";
574  },
575  {
576  name = "group2";
577  isGroup2 = true;
578  },
579  {
580  }
581  );
582 
583  emptyGroup = {}
584  """)
585 
586  config2 = Configuration("""
587  str = "hello world";
588  int = 123;
589  otherFloat = -4.56;
590  group =
591  {
592  str = "baz";
593  int = -789;
594  float = -10.0;
595  };
596 
597  list = (0, 1, 3);
598 
599  listOfGroups =
600  (
601  {
602  },
603  {
604  name = "group2";
605  isGroup2 = true;
606  },
607  {
608  }
609  );
610  """)
611 
612  assert len(config1.getDifferencesAsFlatDictionary(config1)) == 0
613  assert len(config2.getDifferencesAsFlatDictionary(config2)) == 0
614 
615  d1 = config1.getDifferencesAsFlatDictionary(config2)
616  d2 = config2.getDifferencesAsFlatDictionary(config1)
617 
618  expectedElementCount = 0
619 
620  assert "int" in d1
621  assert "int" in d2
622  assert d1["int"] == [[1234], [123]]
623  assert d2["int"] == [[123], [1234]]
624  expectedElementCount += 1
625 
626  assert "float" in d1
627  assert "float" in d2
628  assert d1["float"] == [[-4.56], []]
629  assert d2["float"] == [[], [-4.56]]
630  expectedElementCount += 1
631 
632  assert "otherFloat" in d1
633  assert "otherFloat" in d2
634  assert d1["otherFloat"] == [[], [-4.56]]
635  assert d2["otherFloat"] == [[-4.56], []]
636  expectedElementCount += 1
637 
638  assert "group.str" in d1
639  assert "group.str" in d2
640  assert d1["group.str"] == [["foobar"], ["baz"]]
641  assert d2["group.str"] == [["baz"], ["foobar"]]
642  expectedElementCount += 1
643 
644  assert "group.group.str" in d1
645  assert "group.group.str" in d2
646  assert d1["group.group.str"] == [["level3"], []]
647  assert d2["group.group.str"] == [[], ["level3"]]
648  expectedElementCount += 1
649 
650  assert "list.[2]" in d1
651  assert "list.[2]" in d2
652  assert d1["list.[2]"] == [[2], [3]]
653  assert d2["list.[2]"] == [[3], [2]]
654  expectedElementCount += 1
655 
656  assert "list.[3]" in d1
657  assert "list.[3]" in d2
658  assert d1["list.[3]"] == [[3], []]
659  assert d2["list.[3]"] == [[], [3]]
660  expectedElementCount += 1
661 
662  assert "listOfGroups.[0]" in d1
663  assert "listOfGroups.[0]" in d2
664  assert d1["listOfGroups.[0]"] == [[], [None]]
665  assert d2["listOfGroups.[0]"] == [[None], []]
666  expectedElementCount += 1
667 
668  assert "listOfGroups.[0].name" in d1
669  assert "listOfGroups.[0].name" in d2
670  assert d1["listOfGroups.[0].name"] == [["group1"], []]
671  assert d2["listOfGroups.[0].name"] == [[], ["group1"]]
672  expectedElementCount += 1
673 
674  assert "emptyGroup" in d1
675  assert "emptyGroup" in d2
676  assert d1["emptyGroup"] == [[None], []]
677  assert d2["emptyGroup"] == [[], [None]]
678  expectedElementCount += 1
679 
680  assert len(d1) == expectedElementCount
681  assert len(d2) == expectedElementCount
682 
683 
684 
685 def test_saveToParameterFile():
686  import pytest
687  import tempfile
688 
689  with tempfile.NamedTemporaryFile("w") as tmpf:
690  path = tmpf.name
691 
692  config = Configuration("""
693  str = "hello world";
694  int = 1234;
695  float = -4.56;
696  group =
697  {
698  str = "foobar";
699  int = -789;
700  float = -10.0;
701  group =
702  {
703  str = "level3";
704  };
705  };
706 
707  list = (0, 1, 2, 3);
708 
709  listOfGroups =
710  (
711  {
712  name = "group1";
713  },
714  {
715  name = "group2";
716  isGroup2 = true;
717  },
718  {
719  }
720  );
721 
722  emptyGroup = {}
723  """)
724 
725 
726  with pytest.raises(TypeError):
727  config.saveToParameterFile(0)
728  with pytest.raises(TypeError):
729  config.saveToParameterFile("/tmp/foo", [])
730 
731 
732  listOfAdditionalParameters = []
733  listOfAdditionalParameters.append({})
734  listOfAdditionalParameters.append(
735  {
736  "another-param" : 1.234,
737  "additional-param": "foo",
738  })
739 
740  for additionalParameters in listOfAdditionalParameters:
741  config.saveToParameterFile(path, additionalParameters)
742 
743  with open(path, "r") as f:
744  lineCount = 0
745 
746  for line in f:
747  lineCount += 1
748 
749  if lineCount == 1:
750  headerLine = line
751  else:
752  valueLine = line
753 
754  assert lineCount == 2
755 
756  flatDict = config.getAsFlatDictionary()
757  flatDict.update(additionalParameters)
758 
759  assert headerLine == "\t".join(sorted(flatDict)) + "\n"
760 
761  expectedValueLine = ""
762  for key in sorted(flatDict):
763  if expectedValueLine:
764  expectedValueLine += "\t"
765 
766  value = flatDict[key]
767 
768  if isinstance(value, str):
769  expectedValueLine += "{" + value + "}"
770  elif value is None:
771  expectedValueLine += "None"
772  elif isinstance(value, bool):
773  expectedValueLine += "true" if value else "false"
774  else:
775  expectedValueLine += str(value)
776 
777  assert valueLine == expectedValueLine
778 
779 def test___getitem__():
780  config = Configuration("""
781  str = "hello world";
782  int = 123;
783  float = -4.56;
784  group =
785  {
786  str = "foobar";
787  int = -789;
788  float = -10.0;
789  group =
790  {
791  str = "level3";
792  };
793  };
794 
795  list = (0, 1, 2, 3);
796 
797  listOfGroups =
798  (
799  {
800  name = "group1";
801  },
802  {
803  name = "group2";
804  isGroup2 = true;
805  }
806  );
807  """)
808 
809 
810  import pytest
811  with pytest.raises(TypeError):
812  config.__getitem__(0)
813  with pytest.raises(TypeError):
814  config.__getitem__(config)
815 
816  with pytest.raises(KeyError):
817  config.__getitem__("malformed..key")
818  with pytest.raises(KeyError):
819  config.__getitem__("malformedKey.")
820  with pytest.raises(KeyError):
821  config.__getitem__(".malformedKey")
822  with pytest.raises(KeyError):
823  config.__getitem__("nonexistent")
824 
825 
826  assert config.__getitem__("str") == "hello world"
827  assert config.__getitem__("int") == 123
828  assert config.__getitem__("group.str") == "foobar"
829  assert config.__getitem__("group").__getitem__("float") == -10.0
830  assert config.__getitem__("listOfGroups").__getitem__("[1].isGroup2") == True
831 
832  config["str"] = "newvalue"
833  config["group.str"] = "barfoo"
834  config["listOfGroups"]["[1].isGroup2"] = False
835  config["newsetting"] = "hello"
836  config["newgroup.setting"] = 777
837  assert config.__getitem__("str") == "newvalue"
838  assert config.__getitem__("group").__getitem__("str") == "barfoo"
839  assert \
840  config.__getitem__("listOfGroups"). \
841  __getitem__("[1]").__getitem__("isGroup2") == False
842  assert \
843  config.__getitem__("listOfGroups").__getitem__("[1].isGroup2") == False
844  assert config.__getitem__("newsetting") == "hello"
845  assert config.__getitem__("newgroup.setting") == 777
846 
847 
848 
849  config = Configuration("foo: [1, 2, 3]")
850  assert config.__getitem__("foo.[0]") == 1
851  assert config.__getitem__("foo.[1]") == 2
852  assert config.__getitem__("foo.[2]") == 3
853  config["foo.[0]"] = 4
854  assert config.__getitem__("foo.[0]") == 4
855  assert config.__getitem__("foo.[1]") == 2
856  assert config.__getitem__("foo.[2]") == 3
857 
858 
859 def test___getitem___arrayInGroup():
860  configString = """
861  group:
862  {
863  array = [1.0, 0.0, -3.5]
864  }
865  """
866  config = Configuration(configString)
867 
868  assert config["group.array.[0]"] == 1.0
869  assert config["group.array.[1]"] == 0.0
870  assert config["group.array.[2]"] == -3.5
871 
872  assert config["group"]["array.[0]"] == 1.0
873  assert config["group"]["array.[1]"] == 0.0
874  assert config["group"]["array.[2]"] == -3.5
875 
876  assert config["group"]["array"]["[0]"] == 1.0
877  assert config["group"]["array"]["[1]"] == 0.0
878  assert config["group"]["array"]["[2]"] == -3.5
879 
880 
881 def test___setitem__():
882  config = Configuration("""
883  str = "hello world";
884  int = 123;
885  float = -4.56;
886  group =
887  {
888  str = "foobar";
889  int = -789;
890  float = -10.0;
891  group =
892  {
893  str = "level3";
894  };
895  };
896 
897  list = (0, 1, 2, 3);
898 
899  listOfGroups =
900  (
901  {
902  name = "group1";
903  },
904  {
905  name = "group2";
906  isGroup2 = true;
907  }
908  );
909  """)
910 
911 
912  import pytest
913  with pytest.raises(TypeError):
914  config.__setitem__(0, 0)
915  with pytest.raises(TypeError):
916  config.__setitem__(config, 0)
917 
918  with pytest.raises(KeyError):
919  config.__setitem__("", 0)
920  with pytest.raises(KeyError):
921  config.__setitem__("malformed..key", 0)
922  with pytest.raises(KeyError):
923  config.__setitem__("malformedKey.", 0)
924  with pytest.raises(KeyError):
925  config.__setitem__(".malformedKey", 0)
926 
927 
928  assert config["str"] == "hello world"
929  assert config["int"] == 123
930  assert config["group.str"] == "foobar"
931  assert config["group"]["float"] == -10.0
932  assert config["listOfGroups"]["[1].isGroup2"] == True
933 
934  config.__setitem__("str", "newvalue")
935  config.__setitem__("group.str", "barfoo")
936  config["listOfGroups"].__setitem__("[1].isGroup2", False)
937  config.__setitem__("newsetting", "hello")
938  config.__setitem__("newgroup.setting", 777)
939  assert config["str"] == "newvalue"
940  assert config["group"]["str"] == "barfoo"
941  assert config["listOfGroups"]["[1]"]["isGroup2"] == False
942  assert config["listOfGroups"]["[1].isGroup2"] == False
943  assert config["newsetting"] == "hello"
944  assert config["newgroup.setting"] == 777
945 
946  config = Configuration("foo: [1, 2, 3]")
947  assert config["foo.[0]"] == 1
948  assert config["foo.[1]"] == 2
949  assert config["foo.[2]"] == 3
950  config.__setitem__("foo.[0]", 4)
951  assert config["foo.[0]"] == 4
952  assert config["foo.[1]"] == 2
953  assert config["foo.[2]"] == 3
954 
955 
956 def test___setitem___newValueIsGroup():
957  configString = """
958  topSetting = 1
959  group:
960  {
961  array = [1.0, 0.0, -3.5]
962  subgroup:
963  {
964  value = "string"
965  }
966  }
967  """
968  config = Configuration(configString)
969 
970  config["copy"] = config["group"]
971 
972  assert config["copy.array.[0]"] == 1.0
973  assert config["copy.array.[1]"] == 0.0
974  assert config["copy.array.[2]"] == -3.5
975  assert config["copy.subgroup.value"] == "string"
976 
977 
978  config["newGroup.copy"] = config["group"]
979 
980  assert config["newGroup.copy.array.[0]"] == 1.0
981  assert config["newGroup.copy.array.[1]"] == 0.0
982  assert config["newGroup.copy.array.[2]"] == -3.5
983  assert config["newGroup.copy.subgroup.value"] == "string"
984 
985 
986 def test___delitem__():
987  configString = """
988  topSetting = 1
989  group:
990  {
991  array = [1.0, 0.0, -3.5]
992  subgroup:
993  {
994  value = "string"
995  }
996  }
997  """
998  config = Configuration(configString)
999 
1000  import pytest
1001  with pytest.raises(TypeError):
1002  del config[0]
1003 
1004  assert "topSetting" in config
1005  assert "group" in config
1006  assert "group.array" in config
1007  assert "group.subgroup" in config
1008  assert "group.subgroup.value" in config
1009 
1010 
1011  del config["foo"]
1012  assert "topSetting" in config
1013  assert "group" in config
1014  assert "group.array" in config
1015  assert "group.subgroup" in config
1016  assert "group.subgroup.value" in config
1017 
1018  del config["group.foo"]
1019  assert "topSetting" in config
1020  assert "group" in config
1021  assert "group.array" in config
1022  assert "group.subgroup" in config
1023  assert "group.subgroup.value" in config
1024 
1025  del config["foo.bar"]
1026  assert "topSetting" in config
1027  assert "group" in config
1028  assert "group.array" in config
1029  assert "group.subgroup" in config
1030  assert "group.subgroup.value" in config
1031 
1032 
1033  del config["group.array"]
1034  assert "topSetting" in config
1035  assert "group" in config
1036  assert not "group.array" in config
1037  assert "group.subgroup" in config
1038  assert "group.subgroup.value" in config
1039 
1040  del config["topSetting"]
1041  assert not "topSetting" in config
1042  assert "group" in config
1043  assert not "group.array" in config
1044  assert "group.subgroup" in config
1045  assert "group.subgroup.value" in config
1046 
1047  del config["group"]
1048  assert not "topSetting" in config
1049  assert not "group" in config
1050  assert not "group.array" in config
1051  assert not "group.subgroup" in config
1052  assert not "group.subgroup.value" in config
1053 
1054 
1055 def test___contains__():
1056  configString = """
1057  topSetting = 1
1058  group:
1059  {
1060  array = [1.0, 0.0, -3.5]
1061  subgroup:
1062  {
1063  value = "string"
1064  }
1065  }
1066  """
1067  config = Configuration(configString)
1068 
1069  import pytest
1070  with pytest.raises(TypeError):
1071  del config[0]
1072 
1073  assert "topSetting" in config
1074  assert "group" in config
1075  assert "group.array" in config
1076  assert "group.subgroup" in config
1077  assert "group.subgroup.value" in config
1078 
1079  assert not "foo" in config
1080  assert not "group.array.subgroup" in config
1081  assert not "group.array.subgroup.value" in config
1082  assert not "group.subgroup.foo" in config
1083  assert not "group.foo" in config
1084  assert not "group.foo.bar" in config
1085 
1086 
1087 def test___repr__():
1088  configString = """
1089  topSetting = 1
1090  group:
1091  {
1092  array = [1.0, 0.0, -3.5]
1093  subgroup:
1094  {
1095  value = "string"
1096  }
1097  }
1098  """
1099 
1100  config = Configuration("")
1101  assert isinstance(config.__repr__(), str)
1102 
1103  config = Configuration(configString)
1104  assert isinstance(config.__repr__(), str)
1105 
1106  loadedConfig = Configuration(config.__repr__())
1107  assert loadedConfig.isEquivalent(config)
MPCDAnalysis.Configuration
Definition: Configuration.py:1
Generated by   doxygen 1.8.17