# -*- coding: utf-8 -*- # ClusterShell.NodeSet test suite # Written by S. Thiell (first version in 2007) """Unit test for NodeSet""" import binascii import copy import pickle import sys import unittest from ClusterShell.NodeSet import RangeSet, RangeSetND, NodeSet, fold, expand from ClusterShell.NodeSet import NodeSetBase, AUTOSTEP_DISABLED, \ NodeSetError, NodeSetParseError, \ NodeSetParseRangeError class NodeSetTest(unittest.TestCase): def _assertEqual(self, pattern, result=None): ns = NodeSet(pattern) if result is None: result = pattern self.assertEqual(str(ns), result) def _assertNode(self, nodeset, nodename): """helper to assert single node presence""" self.assertEqual(str(nodeset), nodename) self.assertEqual(list(nodeset), [nodename]) self.assertEqual(len(nodeset), 1) def testEmptyNode(self): """test NodeSet with empty node""" # empty strings and any strip()able chars are OK for arg in (None, " ", "\n", "\t", " " * 100): nodeset = NodeSet(arg) self.assertEqual(str(nodeset), "") self.assertEqual(len(nodeset), 0) def testUnnumberedNode(self): """test NodeSet with unnumbered node""" nodeset = NodeSet("cws-machin") self._assertNode(nodeset, "cws-machin") def testNodeZero(self): """test NodeSet with node0""" nodeset = NodeSet("supercluster0") self._assertNode(nodeset, "supercluster0") def testNoPrefix(self): """test NodeSet with node without prefix""" nodeset = NodeSet("0cluster") self._assertNode(nodeset, "0cluster") nodeset = NodeSet("[0]cluster") self._assertNode(nodeset, "0cluster") def testWhitespacePrefix(self): """test NodeSet parsing ignoring whitespace""" nodeset = NodeSet(" tigrou2 , tigrou7 , tigrou[5,9-11] ") self.assertEqual(str(nodeset), "tigrou[2,5,7,9-11]") nodeset = NodeSet(" tigrou2 , tigrou5,tigrou7 , tigrou[ 9 - 11 ] ") self.assertEqual(str(nodeset), "tigrou[2,5,7,9-11]") def testWhitespaceInsideNodeName(self): """test NodeSet parsing keeping whitespaces inside a node name""" nodeset = NodeSet("tigrou 0, tigrou [1],tigrou [2-3]") self.assertEqual(str(nodeset), "tigrou [0-3]") nsstr = "tigrou 1,tigrou 0 1 2 abc,tigrou [2-3] ourgit" nodeset = NodeSet(nsstr) self.assertEqual(str(nodeset), nsstr) nsstr = " tigrou [1-5] & tigrou [0,2,4] ! tigrou [2-3]" nsstr += " ^ tigrou [3-5], tigrou 1 " nodeset = NodeSet(nsstr) self.assertEqual(str(nodeset), "tigrou [1,3,5]") def testFromListConstructor(self): """test NodeSet.fromlist() constructor""" nodeset = NodeSet.fromlist(["cluster33"]) self._assertNode(nodeset, "cluster33") nodeset = NodeSet.fromlist(["cluster0", "cluster1", "cluster2", "cluster5", "cluster8", "cluster4", "cluster3"]) self.assertEqual(str(nodeset), "cluster[0-5,8]") self.assertEqual(len(nodeset), 7) # updaten() test nodeset.updaten(["cluster10", "cluster9"]) self.assertEqual(str(nodeset), "cluster[0-5,8-10]") self.assertEqual(len(nodeset), 9) # single nodes test nodeset = NodeSet.fromlist(["cluster0", "cluster1", "cluster", "wool", "cluster3"]) self.assertEqual(str(nodeset), "cluster,cluster[0-1,3],wool") self.assertEqual(len(nodeset), 5) def testDigitInPrefix(self): """test NodeSet digit in prefix""" nodeset = NodeSet("clu-0-3") self._assertNode(nodeset, "clu-0-3") nodeset = NodeSet("clu-0-[3-23]") self.assertEqual(str(nodeset), "clu-0-[3-23]") def testNodeWithPercent(self): """test NodeSet on nodename with % character""" # unindexed node with percent (issue #261) nodeset = NodeSet("cluster%s") self._assertNode(nodeset, "cluster%s") # single node indexed nodeset = NodeSet("cluster%s3") self._assertNode(nodeset, "cluster%s3") # more nodes nodeset = NodeSet("clust%ser[3-30]") self.assertEqual(str(nodeset), "clust%ser[3-30]") nodeset = NodeSet("myclu%ster,clust%ser[3-30]") self.assertEqual(str(nodeset), "clust%ser[3-30],myclu%ster") # issue #275 nodeset = NodeSet.fromlist(["cluster%eth0", "cluster%eth1"]) self.assertEqual(str(nodeset), "cluster%eth[0-1]") nodeset = NodeSet.fromlist(["cluster%eth[0-8]", "cluster%eth9"]) self.assertEqual(str(nodeset), "cluster%eth[0-9]") nodeset = NodeSet.fromlist(["super%cluster", "hyper%cluster"]) self.assertEqual(str(nodeset), "hyper%cluster,super%cluster") # test also private _fromlist1 constructor nodeset = NodeSet._fromlist1(["cluster%eth0", "cluster%eth1"]) self.assertEqual(str(nodeset), "cluster%eth[0-1]") nodeset = NodeSet._fromlist1(["super%cluster", "hyper%cluster"]) self.assertEqual(str(nodeset), "hyper%cluster,super%cluster") # real use-case!? exercise nD and escaping! nodeset = NodeSet("fe80::5054:ff:feff:6944%eth0 ") self._assertNode(nodeset, "fe80::5054:ff:feff:6944%eth0") nodeset = NodeSet.fromlist(["fe80::5054:ff:feff:6944%eth0"]) self._assertNode(nodeset, "fe80::5054:ff:feff:6944%eth0") nodeset = NodeSet._fromlist1(["fe80::5054:ff:feff:6944%eth0"]) self._assertNode(nodeset, "fe80::5054:ff:feff:6944%eth0") def _assertNS(self, pattern, expected_exc): self.assertRaises(expected_exc, NodeSet, pattern) def testBadRangeUsages(self): """test NodeSet parse errors in range""" self._assertNS("nova[]", NodeSetParseRangeError) self._assertNS("nova[-]", NodeSetParseRangeError) self._assertNS("nova[A]", NodeSetParseRangeError) self._assertNS("nova[2-5/a]", NodeSetParseRangeError) self._assertNS("nova[3/2]", NodeSetParseRangeError) self._assertNS("nova[3-/2]", NodeSetParseRangeError) self._assertNS("nova[-/2]", NodeSetParseRangeError) self._assertNS("nova[4-a/2]", NodeSetParseRangeError) self._assertNS("nova[4-3/2]", NodeSetParseRangeError) self._assertNS("nova[4-5/-2]", NodeSetParseRangeError) self._assertNS("nova[4-2/-2]", NodeSetParseRangeError) self._assertNS("nova[004-002]", NodeSetParseRangeError) self._assertNS("nova[3-59/2,102a]", NodeSetParseRangeError) self._assertNS("nova[3-59/2,,102]", NodeSetParseRangeError) self._assertNS("nova%s" % ("3" * 101), NodeSetParseRangeError) # nD self._assertNS("nova[]p0", NodeSetParseRangeError) self._assertNS("nova[-]p0", NodeSetParseRangeError) self._assertNS("nova[A]p0", NodeSetParseRangeError) self._assertNS("nova[2-5/a]p0", NodeSetParseRangeError) self._assertNS("nova[3/2]p0", NodeSetParseRangeError) self._assertNS("nova[3-/2]p0", NodeSetParseRangeError) self._assertNS("nova[-/2]p0", NodeSetParseRangeError) self._assertNS("nova[4-a/2]p0", NodeSetParseRangeError) self._assertNS("nova[4-3/2]p0", NodeSetParseRangeError) self._assertNS("nova[4-5/-2]p0", NodeSetParseRangeError) self._assertNS("nova[4-2/-2]p0", NodeSetParseRangeError) self._assertNS("nova[004-002]p0", NodeSetParseRangeError) self._assertNS("nova[3-59/2,102a]p0", NodeSetParseRangeError) self._assertNS("nova[3-59/2,,102]p0", NodeSetParseRangeError) self._assertNS("nova%sp0" % ("3" * 101), NodeSetParseRangeError) self._assertNS("x4nova[]p0", NodeSetParseRangeError) self._assertNS("x4nova[-]p0", NodeSetParseRangeError) self._assertNS("x4nova[A]p0", NodeSetParseRangeError) self._assertNS("x4nova[2-5/a]p0", NodeSetParseRangeError) self._assertNS("x4nova[3/2]p0", NodeSetParseRangeError) self._assertNS("x4nova[3-/2]p0", NodeSetParseRangeError) self._assertNS("x4nova[-/2]p0", NodeSetParseRangeError) self._assertNS("x4nova[4-a/2]p0", NodeSetParseRangeError) self._assertNS("x4nova[4-3/2]p0", NodeSetParseRangeError) self._assertNS("x4nova[4-5/-2]p0", NodeSetParseRangeError) self._assertNS("x4nova[4-2/-2]p0", NodeSetParseRangeError) self._assertNS("x4nova[004-002]p0", NodeSetParseRangeError) self._assertNS("x4nova[3-59/2,102a]p0", NodeSetParseRangeError) self._assertNS("x4nova[3-59/2,,102]p0", NodeSetParseRangeError) self._assertNS("x4nova%sp0" % ("3" * 101), NodeSetParseRangeError) def testBadUsages(self): """test NodeSet other parse errors""" self._assertNS("nova[3-59/2,102", NodeSetParseError) self._assertNS("nova3,nova4,,nova6", NodeSetParseError) self._assertNS("nova6,", NodeSetParseError) self._assertNS("nova6[", NodeSetParseError) self._assertNS("nova6]", NodeSetParseError) self._assertNS("n6[1-4]]", NodeSetParseError) # reopening bracket: no pfx/sfx between delimited ranges self._assertNS("n[1-4]0[3-4]", NodeSetParseError) self._assertNS("n6[1-4][3-4]", NodeSetParseError) self._assertNS("n6[1-4]56[3-4]", NodeSetParseError) # illegal numerical bracket folding with /step syntax self._assertNS("prod-0[01-06/2]0", NodeSetParseError) self._assertNS("prod-0[1-7/2,9]0", NodeSetParseError) self._assertNS("prod-0[1-5/2,7-9]0", NodeSetParseError) self._assertNS("prod-00[1-6/2]0", NodeSetParseError) # and not NodeSetParseRangeError # nD more self._assertNS("[1-30][4-9]", NodeSetParseError) self._assertNS("[1-30][4-9]p", NodeSetParseError) self._assertNS("x[1-30][4-9]p", NodeSetParseError) self._assertNS("x[1-30]p4-9]", NodeSetParseError) self._assertNS("xazer][1-30]p[4-9]", NodeSetParseError) self._assertNS("xa[[zer[1-30]p[4-9]", NodeSetParseRangeError) def testTypeSanityCheck(self): """test NodeSet input type sanity check""" self.assertRaises(TypeError, NodeSet, dict()) self.assertRaises(TypeError, NodeSet, list()) self.assertRaises(ValueError, NodeSetBase, None, RangeSet("1-10")) def testRangeSetEntryMismatch(self): """test NodeSet RangeSet entry mismatch""" nodeset = NodeSet("toto%s") self.assertRaises(NodeSetError, nodeset._add, "toto%%s", RangeSet("5")) def test_binary_bad_object_type(self): nodeset = NodeSet("cluster[1-30]c[1-2]") class Dummy: pass dummy = Dummy() self.assertRaises(TypeError, nodeset.add, dummy) def test_internal_mismatch(self): nodeset = NodeSet("cluster[1-30]c[1-2]") self.assertTrue("cluster%sc%s" in nodeset._patterns) nodeset._patterns["cluster%sc%s"] = RangeSetND([[1]]) self.assertRaises(NodeSetParseError, str, nodeset) nodeset._patterns["cluster%sc%s"] = RangeSetND([[1, 1]]) self.assertEqual(str(nodeset), "cluster1c1") nodeset._patterns["cluster%sc%s"] = RangeSetND([[1, 1, 1]]) self.assertRaises(NodeSetParseError, str, nodeset) def test_empty_operand(self): # right self.assertRaises(NodeSetParseError, NodeSet, "foo!") self.assertRaises(NodeSetParseError, NodeSet, "foo,") self.assertRaises(NodeSetParseError, NodeSet, "foo&") self.assertRaises(NodeSetParseError, NodeSet, "foo^") self.assertRaises(NodeSetParseError, NodeSet, "c[1-30]c[1-2]!") # left self.assertRaises(NodeSetParseError, NodeSet, "!foo") self.assertRaises(NodeSetParseError, NodeSet, ",foo") self.assertRaises(NodeSetParseError, NodeSet, "&foo") self.assertRaises(NodeSetParseError, NodeSet, "^foo") self.assertRaises(NodeSetParseError, NodeSet, "!c[1-30]c[1-2]") # other self.assertRaises(NodeSetParseError, NodeSet, "!") self.assertRaises(NodeSetParseError, NodeSet, ",") self.assertRaises(NodeSetParseError, NodeSet, "&") self.assertRaises(NodeSetParseError, NodeSet, "^") self.assertRaises(NodeSetParseError, NodeSet, ",,,") self.assertRaises(NodeSetParseError, NodeSet, "foo,,bar") def testNodeEightPad(self): """test NodeSet padding feature""" nodeset = NodeSet("cluster008") self._assertNode(nodeset, "cluster008") def testNodeRangeIncludingZero(self): """test NodeSet with node range including zero""" nodeset = NodeSet("cluster[0-10]") self.assertEqual(str(nodeset), "cluster[0-10]") self.assertEqual(list(nodeset), ["cluster0", "cluster1", "cluster2", "cluster3", "cluster4", "cluster5", "cluster6", "cluster7", "cluster8", "cluster9", "cluster10"]) self.assertEqual(len(nodeset), 11) def testSingle(self): """test NodeSet single cluster node""" nodeset = NodeSet("cluster115") self._assertNode(nodeset, "cluster115") def testSingleNodeInRange(self): """test NodeSet single cluster node in range""" nodeset = NodeSet("cluster[115]") self._assertNode(nodeset, "cluster115") def testRange(self): """test NodeSet with simple range""" nodeset = NodeSet("cluster[1-100]") self.assertEqual(str(nodeset), "cluster[1-100]") self.assertEqual(len(nodeset), 100) i = 1 for n in nodeset: self.assertEqual(n, "cluster%d" % i) i += 1 self.assertEqual(i, 101) lst = copy.deepcopy(list(nodeset)) i = 1 for n in lst: self.assertEqual(n, "cluster%d" % i) i += 1 self.assertEqual(i, 101) def testRangeWithPadding1(self): """test NodeSet with range with padding (1)""" nodeset = NodeSet("cluster[0001-0100]") self.assertEqual(str(nodeset), "cluster[0001-0100]") self.assertEqual(len(nodeset), 100) i = 1 for n in nodeset: self.assertEqual(n, "cluster%04d" % i) i += 1 self.assertEqual(i, 101) def testRangeWithPadding2(self): """test NodeSet with range with padding (2)""" nodeset = NodeSet("cluster[0034-8127]") self.assertEqual(str(nodeset), "cluster[0034-8127]") self.assertEqual(len(nodeset), 8094) i = 34 for n in nodeset: self.assertEqual(n, "cluster%04d" % i) i += 1 self.assertEqual(i, 8128) def testRangeWithSuffix(self): """test NodeSet with simple range with suffix""" nodeset = NodeSet("cluster[50-99]-ipmi") self.assertEqual(str(nodeset), "cluster[50-99]-ipmi") i = 50 for n in nodeset: self.assertEqual(n, "cluster%d-ipmi" % i) i += 1 self.assertEqual(i, 100) def testCommaSeparatedAndRangeWithPadding(self): """test NodeSet comma separated, range and padding""" nodeset = NodeSet("cluster[0001,0002,1555-1559]") self.assertEqual(str(nodeset), "cluster[0001-0002,1555-1559]") self.assertEqual(list(nodeset), ["cluster0001", "cluster0002", "cluster1555", "cluster1556", "cluster1557", "cluster1558", "cluster1559"]) def testCommaSeparatedAndRangeWithPaddingWithSuffix(self): """test NodeSet comma separated, range and padding with suffix""" nodeset = NodeSet("cluster[0001,0002,1555-1559]-ipmi") self.assertEqual(str(nodeset), "cluster[0001-0002,1555-1559]-ipmi") self.assertEqual(list(nodeset), ["cluster0001-ipmi", "cluster0002-ipmi", "cluster1555-ipmi", "cluster1556-ipmi", "cluster1557-ipmi", "cluster1558-ipmi", "cluster1559-ipmi"]) def testVeryBigRange(self): """test NodeSet iterations with big range size""" nodeset = NodeSet("bigcluster[1-1000000]") self.assertEqual(str(nodeset), "bigcluster[1-1000000]") self.assertEqual(len(nodeset), 1000000) i = 1 for n in nodeset: assert n == "bigcluster%d" % i i += 1 def test_numerical_bracket_folding(self): """test NodeSet numerical bracket folding (eg. 1[2-3]4)""" # Ticket #228 nodeset = NodeSet("node0[0]") self.assertEqual(str(nodeset), "node00") nodeset = NodeSet("node0[1]") self.assertEqual(str(nodeset), "node01") nodeset = NodeSet("node1[0]") self.assertEqual(str(nodeset), "node10") nodeset = NodeSet("node01[0-1]") self.assertEqual(str(nodeset), "node[010-011]") nodeset = NodeSet("prod-02[10-20]") self.assertEqual(str(nodeset), "prod-[0210-0220]") nodeset = NodeSet("prod-2[10-320]") self.assertEqual(str(nodeset), "prod-[210-2320]") nodeset = NodeSet("prod-02[010-320]") self.assertEqual(str(nodeset), "prod-[02010-02320]") nodeset = NodeSet("prod-000[1-9]") self.assertEqual(str(nodeset), "prod-[0001-0009]") nodeset = NodeSet("prod-100[1-9]") self.assertEqual(str(nodeset), "prod-[1001-1009]") nodeset = NodeSet("prod-100[040-042]") self.assertEqual(str(nodeset), "prod-[100040-100042]") self.assertEqual(len(nodeset), 3) # complex ranges nodeset = NodeSet("prod-10[01,05,09-15,40-50,52]") self.assertEqual(str(nodeset), "prod-[1001,1005,1009-1015,1040-1050,1052]") nodeset.autostep = 3 self.assertEqual(str(nodeset), "prod-[1001-1009/4,1010-1015,1040-1050,1052]") # multi patterns nodeset = NodeSet("prod-0[040-042],sysgrp-00[01-02]") self.assertEqual(str(nodeset), "prod-[0040-0042],sysgrp-[0001-0002]") nodeset = NodeSet("prod-100[040-042],sysgrp-00[01-02]") self.assertEqual(str(nodeset), "prod-[100040-100042],sysgrp-[0001-0002]") # leading digits with step notation (supported) nodeset = NodeSet("prod-000[0-8/2]", autostep=3) self.assertEqual(str(nodeset), "prod-[0000-0008/2]") nodeset = NodeSet("n1[01-40/4]", autostep=3) self.assertEqual(str(nodeset), "n[101-137/4]") nodeset = NodeSet("prod-000[0-8/2],prod-000[1-9/2]") self.assertEqual(str(nodeset), "prod-[0000-0009]") self.assertEqual(len(nodeset), 10) # Tricky case due to absence of padding: the one that requires # RangeSet.contiguous() in ParsingEngine._amend_leading_digits() nodeset = NodeSet("node-1[0-48/16]") # => not equal to node-[10-148/16]! self.assertEqual(str(nodeset), "node-[10,116,132,148]") self.assertEqual(len(nodeset), 4) # same case with padding nodeset = NodeSet("node-1[00-48/16]") # equal to node-[100-148/16] self.assertEqual(nodeset, NodeSet("node-[100-148/16]")) self.assertEqual(str(nodeset), "node-[100,116,132,148]") self.assertEqual(len(nodeset), 4) # see also NodeSetErrorTest.py for unsupported trailing digits w/ steps # /!\ padding mismatch cases: mixed padding allowed since 1.9 nodeset = NodeSet("prod-1[10-345]") # no padding so no mismatch there: OK self.assertEqual(str(nodeset), "prod-[110-1345]") nodeset = NodeSet("prod-02[10-34,069-099]") # no padding mismatch within a range: OK self.assertEqual(str(nodeset), "prod-[0210-0234,02069-02099]") self._assertNS("prod-0[10-345]", NodeSetParseRangeError) # padding length mismatch in a range self._assertNS("prod-02[10-345]", NodeSetParseRangeError) # padding length mismatch in a range # numerical folding with nD nodesets nodeset = NodeSet("x01[0-1]y01[0-1]z01[0-1]") self.assertEqual(str(nodeset), "x[010-011]y[010-011]z[010-011]") self.assertEqual(len(nodeset), 2*2*2) nodeset = NodeSet("x22[0-1]y00[0-1]z03[0-1]") self.assertEqual(str(nodeset), "x[220-221]y[000-001]z[030-031]") self.assertEqual(len(nodeset), 2*2*2) nodeset = NodeSet("x22[0-1]y000z03[0-1]") self.assertEqual(str(nodeset), "x[220-221]y000z[030-031]") self.assertEqual(len(nodeset), 2*1*2) # trigger trailing digits to step code nodeset = NodeSet("x22[0-1]0y03[0-1]0") self.assertEqual(str(nodeset), "x[2200,2210]y[0300,0310]") self.assertEqual(len(nodeset), 4) nodeset = NodeSet("x22[0-1]0y03[0-1]0-ipmi") self.assertEqual(str(nodeset), "x[2200,2210]y[0300,0310]-ipmi") self.assertEqual(len(nodeset), 4) # more numerical folding (with suffix) nodeset = NodeSet("node[0]0") self.assertEqual(str(nodeset), "node00") nodeset = NodeSet("node[0]1") self.assertEqual(str(nodeset), "node01") nodeset = NodeSet("node[1]0") self.assertEqual(str(nodeset), "node10") nodeset = NodeSet("n[1-9,15,59,10-50,142]0") self.assertEqual(str(nodeset), str(NodeSet("n[10-90/10,150,590,100-500/10,1420]"))) self.assertEqual(nodeset, NodeSet("n[10-90/10,150,590,100-500/10,1420]")) nodeset = NodeSet("nova[1-4]56") self.assertEqual(nodeset, NodeSet("nova[156-456/100]")) self.assertEqual(len(nodeset), 4) nodeset = NodeSet("nova16[1-4]56") self.assertEqual(str(nodeset), "nova[16156,16256,16356,16456]") self.assertEqual(len(nodeset), 4) nodeset = NodeSet("nova16[1-4]56c") self.assertEqual(str(nodeset), "nova[16156,16256,16356,16456]c") self.assertEqual(len(nodeset), 4) nodeset = NodeSet("prod-[01-34]0") self.assertEqual(nodeset, NodeSet("prod-[010-340/10]")) nodeset = NodeSet("prod-01[1-5]0") self.assertEqual(nodeset, NodeSet("prod-[0110-0150/10]")) nodeset = NodeSet("node123[1-2]") self.assertEqual(nodeset, NodeSet("node[1231-1232]")) self.assertEqual(str(nodeset), "node[1231-1232]") inodeset = NodeSet("node1232") self.assertEqual(str(nodeset.intersection(inodeset)), "node1232") nodeset = NodeSet("node0[0]0") self.assertEqual(str(nodeset), "node000") nodeset = NodeSet("node0[1]0") self.assertEqual(str(nodeset), "node010") nodeset = NodeSet("node1[0]1") self.assertEqual(str(nodeset), "node101") nodeset = NodeSet("node01[0]10") self.assertEqual(str(nodeset), "node01010") # misordered ranges nodeset = NodeSet("n1[1-9,15,59,10-50,142]0") self.assertEqual(nodeset, NodeSet("n[110-190/10,1100-1500/10,1590,11420]")) # more nD (with suffix) nodeset = NodeSet("x01[0-1]y01[0-1]z01[0-1]-ipmi") self.assertEqual(str(nodeset), "x[010-011]y[010-011]z[010-011]-ipmi") self.assertEqual(len(nodeset), 2*2*2) # #284 - hostname labels starting with digits (RFC 1123) nodeset = NodeSet("0[3-9/2]abc") self.assertEqual(str(nodeset), "[03,05,07,09]abc") nodeset = NodeSet("0[3-9]abc") self.assertEqual(str(nodeset), "[03-09]abc") nodeset = NodeSet("[3,5,7,9]0abc") self.assertEqual(str(nodeset), "[30,50,70,90]abc") nodeset = NodeSet("[3-9]0abc") self.assertEqual(str(nodeset), "[30,40,50,60,70,80,90]abc") nodeset = NodeSet("3abc0[1]0") self.assertEqual(str(nodeset), "3abc010") nodeset = NodeSet("3abc16[1-4]56d") self.assertEqual(str(nodeset), "3abc[16156,16256,16356,16456]d") nodeset = NodeSet("0[3,6,9]1abc16[1-4]56d") self.assertEqual(str(nodeset), "[031,061,091]abc[16156,16256,16356,16456]d") # bogus range with padding, we are stricter in v1.9+ self._assertNS("0123[0-100]L6", NodeSetParseRangeError) # ok when no mismatch within a given range nodeset = NodeSet("[01230-99999,100000-123100]L6") self.assertEqual(str(nodeset), "[01230-99999,100000-123100]L6") nodeset = NodeSet("0123[000-100]L6") self.assertEqual(str(nodeset), "[0123000-0123100]L6") def testCommaSeparated(self): """test NodeSet comma separated to ranges (folding)""" nodeset = NodeSet("cluster115,cluster116,cluster117,cluster130," "cluster166") self.assertEqual(str(nodeset), "cluster[115-117,130,166]") self.assertEqual(len(nodeset), 5) def testCommaSeparatedAndRange(self): """test NodeSet comma separated and range to ranges (folding)""" nodeset = NodeSet("cluster115,cluster116,cluster117,cluster130," "cluster[166-169],cluster170") self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") def testCommaSeparatedAndRanges(self): """test NodeSet comma separated and ranges to ranges (folding)""" nodeset = NodeSet("cluster[115-117],cluster130,cluster[166-169]," "cluster170") self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") def testSimpleStringUpdates(self): """test NodeSet simple string-based update()""" nodeset = NodeSet("cluster[115-117,130,166-170]") self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") nodeset.update("cluster171") self.assertEqual(str(nodeset), "cluster[115-117,130,166-171]") nodeset.update("cluster172") self.assertEqual(str(nodeset), "cluster[115-117,130,166-172]") nodeset.update("cluster174") self.assertEqual(str(nodeset), "cluster[115-117,130,166-172,174]") nodeset.update("cluster113") self.assertEqual(str(nodeset), "cluster[113,115-117,130,166-172,174]") nodeset.update("cluster173") self.assertEqual(str(nodeset), "cluster[113,115-117,130,166-174]") nodeset.update("cluster114") self.assertEqual(str(nodeset), "cluster[113-117,130,166-174]") def test_nd_fold_axis_errors(self): """test NodeSet fold_axis errors""" n1 = NodeSet("a3b2c0,a2b3c1,a2b4c1,a1b2c0,a1b2c1,a3b2c1,a2b5c1") n1.fold_axis = 0 self.assertRaises(NodeSetParseError, str, n1) n1.fold_axis = 1 self.assertRaises(NodeSetParseError, str, n1) n1.fold_axis = "0-1" # nok self.assertRaises(NodeSetParseError, str, n1) n1.fold_axis = range(2) # ok self.assertEqual(str(n1), "a[1,3]b2c0,a[1,3]b2c1,a2b[3-5]c1") self.assertEqual(n1, NodeSet("a[1,3]b2c0,a[1,3]b2c1,a2b[3-5]c1")) n1.fold_axis = RangeSet("0-1") # ok self.assertEqual(str(n1), "a[1,3]b2c0,a[1,3]b2c1,a2b[3-5]c1") self.assertEqual(n1, NodeSet("a[1,3]b2c0,a[1,3]b2c1,a2b[3-5]c1")) n1.fold_axis = (0, 1) # ok self.assertEqual(str(n1), "a[1,3]b2c0,a[1,3]b2c1,a2b[3-5]c1") self.assertEqual(n1, NodeSet("a[1,3]b2c0,a[1,3]b2c1,a2b[3-5]c1")) def testSimpleNodeSetUpdates(self): """test NodeSet simple nodeset-based update()""" nodeset = NodeSet("cluster[115-117,130,166-170]") self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") nodeset.update(NodeSet("cluster171")) self.assertEqual(str(nodeset), "cluster[115-117,130,166-171]") nodeset.update(NodeSet("cluster172")) self.assertEqual(str(nodeset), "cluster[115-117,130,166-172]") nodeset.update(NodeSet("cluster174")) self.assertEqual(str(nodeset), "cluster[115-117,130,166-172,174]") nodeset.update(NodeSet("cluster113")) self.assertEqual(str(nodeset), "cluster[113,115-117,130,166-172,174]") nodeset.update(NodeSet("cluster173")) self.assertEqual(str(nodeset), "cluster[113,115-117,130,166-174]") nodeset.update(NodeSet("cluster114")) self.assertEqual(str(nodeset), "cluster[113-117,130,166-174]") def testStringUpdatesFromEmptyNodeSet(self): """test NodeSet string-based NodeSet.update() from empty nodeset""" nodeset = NodeSet() self.assertEqual(str(nodeset), "") nodeset.update("") self.assertEqual(str(nodeset), "") nodeset.update(" ") self.assertEqual(str(nodeset), "") nodeset.update("cluster115") self.assertEqual(str(nodeset), "cluster115") nodeset.update("cluster118") self.assertEqual(str(nodeset), "cluster[115,118]") nodeset.update("cluster[116-117]") self.assertEqual(str(nodeset), "cluster[115-118]") def testNodeSetUpdatesFromEmptyNodeSet(self): """test NodeSet-based update() method from empty nodeset""" nodeset = NodeSet() self.assertEqual(str(nodeset), "") nodeset.update(NodeSet("cluster115")) self.assertEqual(str(nodeset), "cluster115") nodeset.update(NodeSet("cluster118")) self.assertEqual(str(nodeset), "cluster[115,118]") nodeset.update(NodeSet("cluster[116-117]")) self.assertEqual(str(nodeset), "cluster[115-118]") def testUpdatesWithSeveralPrefixes(self): """test NodeSet.update() using several prefixes""" nodeset = NodeSet("cluster3") self.assertEqual(str(nodeset), "cluster3") nodeset.update("cluster5") self.assertEqual(str(nodeset), "cluster[3,5]") nodeset.update("tiger5") self.assertEqual(str(nodeset), "cluster[3,5],tiger5") nodeset.update("tiger7") self.assertEqual(str(nodeset), "cluster[3,5],tiger[5,7]") nodeset.update("tiger6") self.assertEqual(str(nodeset), "cluster[3,5],tiger[5-7]") nodeset.update("cluster4") self.assertEqual(str(nodeset), "cluster[3-5],tiger[5-7]") def testOperatorUnion(self): """test NodeSet union | operator""" nodeset = NodeSet("cluster[115-117,130,166-170]") self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") # 1 n_test1 = nodeset | NodeSet("cluster171") self.assertEqual(str(n_test1), "cluster[115-117,130,166-171]") nodeset2 = nodeset.copy() self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") nodeset2 |= NodeSet("cluster171") self.assertEqual(str(nodeset2), "cluster[115-117,130,166-171]") # btw validate modifying a copy did not change original self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") # 2 n_test2 = n_test1 | NodeSet("cluster172") self.assertEqual(str(n_test2), "cluster[115-117,130,166-172]") nodeset2 |= NodeSet("cluster172") self.assertEqual(str(nodeset2), "cluster[115-117,130,166-172]") self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") # 3 n_test1 = n_test2 | NodeSet("cluster113") self.assertEqual(str(n_test1), "cluster[113,115-117,130,166-172]") nodeset2 |= NodeSet("cluster113") self.assertEqual(str(nodeset2), "cluster[113,115-117,130,166-172]") self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") # 4 n_test2 = n_test1 | NodeSet("cluster114") self.assertEqual(str(n_test2), "cluster[113-117,130,166-172]") nodeset2 |= NodeSet("cluster114") self.assertEqual(str(nodeset2), "cluster[113-117,130,166-172]") self.assertEqual(nodeset2, NodeSet("cluster[113-117,130,166-172]")) self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") # more original = NodeSet("cluster0") nodeset = original.copy() for i in range(1, 3000): nodeset = nodeset | NodeSet("cluster%d" % i) self.assertEqual(len(nodeset), 3000) self.assertEqual(str(nodeset), "cluster[0-2999]") self.assertEqual(len(original), 1) self.assertEqual(str(original), "cluster0") nodeset2 = original.copy() for i in range(1, 3000): nodeset2 |= NodeSet("cluster%d" % i) self.assertEqual(nodeset, nodeset2) for i in range(3000, 5000): nodeset2 |= NodeSet("cluster%d" % i) self.assertEqual(len(nodeset2), 5000) self.assertEqual(str(nodeset2), "cluster[0-4999]") self.assertEqual(len(nodeset), 3000) self.assertEqual(str(nodeset), "cluster[0-2999]") self.assertEqual(len(original), 1) self.assertEqual(str(original), "cluster0") def testOperatorUnionFromEmptyNodeSet(self): """test NodeSet union | operator from empty nodeset""" nodeset = NodeSet() self.assertEqual(str(nodeset), "") n_test1 = nodeset | NodeSet("cluster115") self.assertEqual(str(n_test1), "cluster115") n_test2 = n_test1 | NodeSet("cluster118") self.assertEqual(str(n_test2), "cluster[115,118]") n_test1 = n_test2 | NodeSet("cluster[116,117]") self.assertEqual(str(n_test1), "cluster[115-118]") def testOperatorUnionWithSeveralPrefixes(self): """test NodeSet union | operator using several prefixes""" nodeset = NodeSet("cluster3") self.assertEqual(str(nodeset), "cluster3") n_test1 = nodeset | NodeSet("cluster5") self.assertEqual(str(n_test1), "cluster[3,5]") n_test2 = n_test1 | NodeSet("tiger5") self.assertEqual(str(n_test2), "cluster[3,5],tiger5") n_test1 = n_test2 | NodeSet("tiger7") self.assertEqual(str(n_test1), "cluster[3,5],tiger[5,7]") n_test2 = n_test1 | NodeSet("tiger6") self.assertEqual(str(n_test2), "cluster[3,5],tiger[5-7]") n_test1 = n_test2 | NodeSet("cluster4") self.assertEqual(str(n_test1), "cluster[3-5],tiger[5-7]") def testOperatorSub(self): """test NodeSet difference/sub - operator""" nodeset = NodeSet("cluster[115-117,130,166-170]") self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") # __sub__ n_test1 = nodeset - NodeSet("cluster[115,130]") self.assertEqual(str(n_test1), "cluster[116-117,166-170]") nodeset2 = copy.copy(nodeset) nodeset2 -= NodeSet("cluster[115,130]") self.assertEqual(str(nodeset2), "cluster[116-117,166-170]") self.assertEqual(nodeset2, NodeSet("cluster[116-117,166-170]")) def testOperatorAnd(self): """test NodeSet intersection/and & operator""" nodeset = NodeSet("cluster[115-117,130,166-170]") self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") # __and__ n_test1 = nodeset & NodeSet("cluster[115-167]") self.assertEqual(str(n_test1), "cluster[115-117,130,166-167]") nodeset2 = copy.copy(nodeset) nodeset2 &= NodeSet("cluster[115-167]") self.assertEqual(str(nodeset2), "cluster[115-117,130,166-167]") self.assertEqual(nodeset2, NodeSet("cluster[115-117,130,166-167]")) def testOperatorXor(self): """test NodeSet symmetric_difference/xor & operator""" nodeset = NodeSet("cluster[115-117,130,166-170]") self.assertEqual(str(nodeset), "cluster[115-117,130,166-170]") # __xor__ n_test1 = nodeset ^ NodeSet("cluster[115-167]") self.assertEqual(str(n_test1), "cluster[118-129,131-165,168-170]") nodeset2 = copy.copy(nodeset) nodeset2 ^= NodeSet("cluster[115-167]") self.assertEqual(str(nodeset2), "cluster[118-129,131-165,168-170]") self.assertEqual(nodeset2, NodeSet("cluster[118-129,131-165,168-170]")) def testLen(self): """test NodeSet len() results""" nodeset = NodeSet() self.assertEqual(len(nodeset), 0) nodeset.update("cluster[116-120]") self.assertEqual(len(nodeset), 5) nodeset = NodeSet("roma[50-99]-ipmi,cors[113,115-117,130,166-172]," "cws-tigrou,tigrou3") self.assertEqual(len(nodeset), 50 + 12 + 1 + 1) nodeset = NodeSet("roma[50-99]-ipmi,cors[113,115-117,130,166-172]," "cws-tigrou,tigrou3,tigrou3,tigrou3,cors116") self.assertEqual(len(nodeset), 50 + 12 + 1 + 1) def testIntersection(self): """test NodeSet.intersection()""" nsstr = "red[34-55,76-249,300-403],blue,green" nodeset = NodeSet(nsstr) self.assertEqual(len(nodeset), 302) nsstr2 = "red[32-57,72-249,300-341],blue,yellow" nodeset2 = NodeSet(nsstr2) self.assertEqual(len(nodeset2), 248) inodeset = nodeset.intersection(nodeset2) # originals should not change self.assertEqual(len(nodeset), 302) self.assertEqual(len(nodeset2), 248) self.assertEqual(str(nodeset), "blue,green,red[34-55,76-249,300-403]") self.assertEqual(str(nodeset2), "blue,red[32-57,72-249,300-341],yellow") # result self.assertEqual(len(inodeset), 239) self.assertEqual(str(inodeset), "blue,red[34-55,76-249,300-341]") def testIntersectUpdate(self): """test NodeSet.intersection_update()""" nsstr = "red[34-55,76-249,300-403]" nodeset = NodeSet(nsstr) self.assertEqual(len(nodeset), 300) nodeset = NodeSet(nsstr) nodeset.intersection_update("red[78-80]") self.assertEqual(str(nodeset), "red[78-80]") nodeset = NodeSet(nsstr) nodeset.intersection_update("red[54-249]") self.assertEqual(str(nodeset), "red[54-55,76-249]") nodeset = NodeSet(nsstr) nodeset.intersection_update("red[55-249]") self.assertEqual(str(nodeset), "red[55,76-249]") nodeset = NodeSet(nsstr) nodeset.intersection_update("red[55-100]") self.assertEqual(str(nodeset), "red[55,76-100]") nodeset = NodeSet(nsstr) nodeset.intersection_update("red[55-76]") self.assertEqual(str(nodeset), "red[55,76]") nodeset = NodeSet(nsstr) nodeset.intersection_update("red[55,76]") self.assertEqual(str(nodeset), "red[55,76]") nodeset = NodeSet(nsstr) nodeset.intersection_update("red55,red76") self.assertEqual(str(nodeset), "red[55,76]") # same with intersect(NodeSet) nodeset = NodeSet(nsstr) nodeset.intersection_update(NodeSet("red[78-80]")) self.assertEqual(str(nodeset), "red[78-80]") nodeset = NodeSet(nsstr) nodeset.intersection_update(NodeSet("red[54-249]")) self.assertEqual(str(nodeset), "red[54-55,76-249]") nodeset = NodeSet(nsstr) nodeset.intersection_update(NodeSet("red[55-249]")) self.assertEqual(str(nodeset), "red[55,76-249]") nodeset = NodeSet(nsstr) nodeset.intersection_update(NodeSet("red[55-100]")) self.assertEqual(str(nodeset), "red[55,76-100]") nodeset = NodeSet(nsstr) nodeset.intersection_update(NodeSet("red[55-76]")) self.assertEqual(str(nodeset), "red[55,76]") nodeset = NodeSet(nsstr) nodeset.intersection_update(NodeSet("red[55,76]")) self.assertEqual(str(nodeset), "red[55,76]") nodeset = NodeSet(nsstr) nodeset.intersection_update(NodeSet("red55,red76")) self.assertEqual(str(nodeset), "red[55,76]") # single nodes test nodeset = NodeSet("red,blue,yellow") nodeset.intersection_update("blue,green,yellow") self.assertEqual(len(nodeset), 2) self.assertEqual(str(nodeset), "blue,yellow") def testIntersectSelf(self): """test Nodeset.intersection_update(self)""" nodeset = NodeSet("red4955") self.assertEqual(len(nodeset), 1) nodeset.intersection_update(nodeset) self.assertEqual(len(nodeset), 1) self.assertEqual(str(nodeset), "red4955") nodeset = NodeSet("red") self.assertEqual(len(nodeset), 1) nodeset.intersection_update(nodeset) self.assertEqual(len(nodeset), 1) self.assertEqual(str(nodeset), "red") nodeset = NodeSet("red") self.assertEqual(len(nodeset), 1) nodeset.intersection_update("red") self.assertEqual(len(nodeset), 1) self.assertEqual(str(nodeset), "red") nodeset = NodeSet("red") self.assertEqual(len(nodeset), 1) nodeset.intersection_update("blue") self.assertEqual(len(nodeset), 0) nodeset = NodeSet("red[78-149]") self.assertEqual(len(nodeset), 72) nodeset.intersection_update(nodeset) self.assertEqual(len(nodeset), 72) self.assertEqual(str(nodeset), "red[78-149]") def testIntersectReturnNothing(self): """test NodeSet intersect that returns empty NodeSet""" nodeset = NodeSet("blue43") self.assertEqual(len(nodeset), 1) nodeset.intersection_update("blue42") self.assertEqual(len(nodeset), 0) def testDifference(self): """test NodeSet.difference()""" nsstr = "red[34-55,76-249,300-403],blue,green" nodeset = NodeSet(nsstr) self.assertEqual(str(nodeset), "blue,green,red[34-55,76-249,300-403]") self.assertEqual(len(nodeset), 302) nsstr2 = "red[32-57,72-249,300-341],blue,yellow" nodeset2 = NodeSet(nsstr2) self.assertEqual(str(nodeset2), "blue,red[32-57,72-249,300-341],yellow") self.assertEqual(len(nodeset2), 248) inodeset = nodeset.difference(nodeset2) # originals should not change self.assertEqual(str(nodeset), "blue,green,red[34-55,76-249,300-403]") self.assertEqual(str(nodeset2), "blue,red[32-57,72-249,300-341],yellow") self.assertEqual(len(nodeset), 302) self.assertEqual(len(nodeset2), 248) # result self.assertEqual(str(inodeset), "green,red[342-403]") self.assertEqual(len(inodeset), 63) inodeset = nodeset.difference("") self.assertEqual(str(inodeset), str(nodeset)) self.assertEqual(inodeset, nodeset) def testDifferenceUpdate(self): """test NodeSet.difference_update()""" # nodeset-based subs nodeset = NodeSet("yellow120") self.assertEqual(len(nodeset), 1) nodeset.difference_update(NodeSet("yellow120")) self.assertEqual(len(nodeset), 0) nodeset = NodeSet("yellow") self.assertEqual(len(nodeset), 1) nodeset.difference_update(NodeSet("yellow")) self.assertEqual(len(nodeset), 0) nodeset = NodeSet("yellow") self.assertEqual(len(nodeset), 1) nodeset.difference_update(NodeSet("blue")) self.assertEqual(len(nodeset), 1) self.assertEqual(str(nodeset), "yellow") nodeset = NodeSet("yellow[45-240,570-764,800]") self.assertEqual(len(nodeset), 392) nodeset.difference_update(NodeSet("yellow[45-240,570-764,800]")) self.assertEqual(len(nodeset), 0) # same with string-based subs nodeset = NodeSet("yellow120") self.assertEqual(len(nodeset), 1) nodeset.difference_update("yellow120") self.assertEqual(len(nodeset), 0) nodeset = NodeSet("yellow") self.assertEqual(len(nodeset), 1) nodeset.difference_update("yellow") self.assertEqual(len(nodeset), 0) nodeset = NodeSet("yellow") self.assertEqual(len(nodeset), 1) nodeset.difference_update("blue") self.assertEqual(len(nodeset), 1) self.assertEqual(str(nodeset), "yellow") nodeset = NodeSet("yellow[45-240,570-764,800]") self.assertEqual(len(nodeset), 392) nodeset.difference_update("yellow[45-240,570-764,800]") self.assertEqual(len(nodeset), 0) def testSubSelf(self): """test NodeSet.difference_update() method (self)""" nodeset = NodeSet("yellow[120-148,167]") nodeset.difference_update(nodeset) self.assertEqual(len(nodeset), 0) def testSubMore(self): """test NodeSet.difference_update() method (more)""" nodeset = NodeSet("yellow[120-160]") self.assertEqual(len(nodeset), 41) for i in range(120, 161): nodeset.difference_update(NodeSet("yellow%d" % i)) self.assertEqual(len(nodeset), 0) def testSubsAndAdds(self): """test NodeSet.update() and difference_update() together""" nodeset = NodeSet("yellow[120-160]") self.assertEqual(len(nodeset), 41) for i in range(120, 131): nodeset.difference_update(NodeSet("yellow%d" % i)) self.assertEqual(len(nodeset), 30) for i in range(1940, 2040): nodeset.update(NodeSet("yellow%d" % i)) self.assertEqual(len(nodeset), 130) def testSubsAndAddsMore(self): """test NodeSet.update() and difference_update() together (more)""" nodeset = NodeSet("yellow[120-160]") self.assertEqual(len(nodeset), 41) for i in range(120, 131): nodeset.difference_update(NodeSet("yellow%d" % i)) nodeset.update(NodeSet("yellow%d" % (i + 1000))) self.assertEqual(len(nodeset), 41) for i in range(1120, 1131): nodeset.difference_update(NodeSet("yellow%d" % i)) nodeset.difference_update(NodeSet("yellow[131-160]")) self.assertEqual(len(nodeset), 0) def testSubsAndAddsMoreDigit(self): """ test NodeSet.update() and difference_update() together (with other digit in prefix) """ nodeset = NodeSet("clu-3-[120-160]") self.assertEqual(len(nodeset), 41) for i in range(120, 131): nodeset.difference_update(NodeSet("clu-3-[%d]" % i)) nodeset.update(NodeSet("clu-3-[%d]" % (i + 1000))) self.assertEqual(len(nodeset), 41) for i in range(1120, 1131): nodeset.difference_update(NodeSet("clu-3-[%d]" % i)) nodeset.difference_update(NodeSet("clu-3-[131-160]")) self.assertEqual(len(nodeset), 0) def testSubUnknownNodes(self): """test NodeSet.difference_update() with unknown nodes""" nodeset = NodeSet("yellow[120-160]") self.assertEqual(len(nodeset), 41) nodeset.difference_update("red[35-49]") self.assertEqual(len(nodeset), 41) self.assertEqual(str(nodeset), "yellow[120-160]") def testSubMultiplePrefix(self): """test NodeSet.difference_update() with multiple prefixes""" nodeset = NodeSet("yellow[120-160],red[32-147],blue3,green," "white[2-3940],blue4,blue303") self.assertEqual(len(nodeset), 4100) for i in range(120, 131): nodeset.difference_update(NodeSet("red%d" % i)) nodeset.update(NodeSet("red%d" % (i + 1000))) nodeset.update(NodeSet("yellow%d" % (i + 1000))) self.assertEqual(len(nodeset), 4111) for i in range(1120, 1131): nodeset.difference_update(NodeSet("red%d" % i)) nodeset.difference_update(NodeSet("white%d" %i)) nodeset.difference_update(NodeSet("yellow[131-160]")) self.assertEqual(len(nodeset), 4059) nodeset.difference_update(NodeSet("green")) self.assertEqual(len(nodeset), 4058) def test_getitem(self): """test NodeSet.__getitem__()""" nodeset = NodeSet("yeti[30,34-51,59-60]") self.assertEqual(len(nodeset), 21) self.assertEqual(nodeset[0], "yeti30") self.assertEqual(nodeset[1], "yeti34") self.assertEqual(nodeset[2], "yeti35") self.assertEqual(nodeset[3], "yeti36") self.assertEqual(nodeset[18], "yeti51") self.assertEqual(nodeset[19], "yeti59") self.assertEqual(nodeset[20], "yeti60") self.assertRaises(IndexError, nodeset.__getitem__, 21) # negative indices self.assertEqual(nodeset[-1], "yeti60") for n in range(1, len(nodeset)): self.assertEqual(nodeset[-n], nodeset[len(nodeset)-n]) self.assertRaises(IndexError, nodeset.__getitem__, -100) # test getitem with some nodes without range nodeset = NodeSet("abc,cde[3-9,11],fgh") self.assertEqual(len(nodeset), 10) self.assertEqual(nodeset[0], "abc") self.assertEqual(nodeset[1], "cde3") self.assertEqual(nodeset[2], "cde4") self.assertEqual(nodeset[3], "cde5") self.assertEqual(nodeset[7], "cde9") self.assertEqual(nodeset[8], "cde11") self.assertEqual(nodeset[9], "fgh") self.assertRaises(IndexError, nodeset.__getitem__, 10) # test getitem with rangeset padding nodeset = NodeSet("prune[003-034,349-353/2]") self.assertEqual(len(nodeset), 35) self.assertEqual(nodeset[0], "prune003") self.assertEqual(nodeset[1], "prune004") self.assertEqual(nodeset[31], "prune034") self.assertEqual(nodeset[32], "prune349") self.assertEqual(nodeset[33], "prune351") self.assertEqual(nodeset[34], "prune353") self.assertRaises(IndexError, nodeset.__getitem__, 35) def test_getslice(self): """test NodeSet getitem() with slice""" nodeset = NodeSet("yeti[30,34-51,59-60]") self.assertEqual(len(nodeset), 21) self.assertEqual(len(nodeset[0:2]), 2) self.assertEqual(str(nodeset[0:2]), "yeti[30,34]") self.assertEqual(len(nodeset[1:3]), 2) self.assertEqual(str(nodeset[1:3]), "yeti[34-35]") self.assertEqual(len(nodeset[19:21]), 2) self.assertEqual(str(nodeset[19:21]), "yeti[59-60]") self.assertEqual(len(nodeset[20:22]), 1) self.assertEqual(str(nodeset[20:22]), "yeti60") self.assertEqual(len(nodeset[21:24]), 0) self.assertEqual(str(nodeset[21:24]), "") # negative indices self.assertEqual(str(nodeset[:-1]), "yeti[30,34-51,59]") self.assertEqual(str(nodeset[:-2]), "yeti[30,34-51]") self.assertEqual(str(nodeset[1:-2]), "yeti[34-51]") self.assertEqual(str(nodeset[2:-2]), "yeti[35-51]") self.assertEqual(str(nodeset[9:-3]), "yeti[42-50]") self.assertEqual(str(nodeset[10:-9]), "yeti[43-44]") self.assertEqual(str(nodeset[10:-10]), "yeti43") self.assertEqual(str(nodeset[11:-10]), "") self.assertEqual(str(nodeset[11:-11]), "") self.assertEqual(str(nodeset[::-2]), "yeti[30,35,37,39,41,43,45,47,49,51,60]") self.assertEqual(str(nodeset[::-3]), "yeti[35,38,41,44,47,50,60]") # advanced self.assertEqual(str(nodeset[0:10:2]), "yeti[30,35,37,39,41]") self.assertEqual(str(nodeset[1:11:2]), "yeti[34,36,38,40,42]") self.assertEqual(str(nodeset[:11:3]), "yeti[30,36,39,42]") self.assertEqual(str(nodeset[11::4]), "yeti[44,48,59]") self.assertEqual(str(nodeset[14:]), "yeti[47-51,59-60]") self.assertEqual(str(nodeset[:]), "yeti[30,34-51,59-60]") self.assertEqual(str(nodeset[::5]), "yeti[30,38,43,48,60]") # with unindexed nodes nodeset = NodeSet("foo,bar,bur") self.assertEqual(len(nodeset), 3) self.assertEqual(len(nodeset[0:2]), 2) self.assertEqual(str(nodeset[0:2]), "bar,bur") self.assertEqual(str(nodeset[1:2]), "bur") self.assertEqual(str(nodeset[1:3]), "bur,foo") self.assertEqual(str(nodeset[2:4]), "foo") nodeset = NodeSet("foo,bar,bur3,bur1") self.assertEqual(len(nodeset), 4) self.assertEqual(len(nodeset[0:2]), 2) self.assertEqual(len(nodeset[1:3]), 2) self.assertEqual(len(nodeset[2:4]), 2) self.assertEqual(len(nodeset[3:5]), 1) self.assertEqual(str(nodeset[2:3]), "bur3") self.assertEqual(str(nodeset[3:4]), "foo") self.assertEqual(str(nodeset[0:2]), "bar,bur1") self.assertEqual(str(nodeset[1:3]), "bur[1,3]") # using range step nodeset = NodeSet("yeti[10-98/2]") self.assertEqual(str(nodeset[1:9:3]), "yeti[12,18,24]") self.assertEqual(str(nodeset[::17]), "yeti[10,44,78]") nodeset = NodeSet("yeti[10-98/2]", autostep=2) self.assertEqual(str(nodeset[22:29]), "yeti[54-66/2]") self.assertEqual(nodeset._autostep, 2) # stepping scalability nodeset = NodeSet("yeti[10-9800/2]", autostep=2) self.assertEqual(str(nodeset[22:2900]), "yeti[54-5808/2]") self.assertEqual(str(nodeset[22:2900:3]), "yeti[54-5808/6]") nodeset = NodeSet("yeti[10-14,20-26,30-33]") self.assertEqual(str(nodeset[2:6]), "yeti[12-14,20]") # multiple patterns nodeset = NodeSet("stone[1-9],wood[1-9]") self.assertEqual(str(nodeset[:]), "stone[1-9],wood[1-9]") self.assertEqual(str(nodeset[1:2]), "stone2") self.assertEqual(str(nodeset[8:9]), "stone9") self.assertEqual(str(nodeset[8:10]), "stone9,wood1") self.assertEqual(str(nodeset[9:10]), "wood1") self.assertEqual(str(nodeset[9:]), "wood[1-9]") nodeset = NodeSet("stone[1-9],water[10-12],wood[1-9]") self.assertEqual(str(nodeset[8:10]), "stone9,water10") self.assertEqual(str(nodeset[11:15]), "water12,wood[1-3]") nodeset = NodeSet("stone[1-9],water,wood[1-9]") self.assertEqual(str(nodeset[8:10]), "stone9,water") self.assertEqual(str(nodeset[8:11]), "stone9,water,wood1") self.assertEqual(str(nodeset[9:11]), "water,wood1") self.assertEqual(str(nodeset[9:12]), "water,wood[1-2]") def test_bad_slices(self): nodeset = NodeSet("cluster[1-30]c[1-2]") self.assertRaises(TypeError, nodeset.__getitem__, "zz") self.assertRaises(TypeError, nodeset.__getitem__, slice(1, 'foo')) def testSplit(self): """test NodeSet split()""" # Empty nodeset nodeset = NodeSet() self.assertEqual((), tuple(nodeset.split(2))) # Not enough element nodeset = NodeSet("foo[1]") self.assertEqual((NodeSet("foo[1]"),), tuple(nodeset.split(2))) # Exact number of elements nodeset = NodeSet("foo[1-6]") self.assertEqual((NodeSet("foo[1-2]"), NodeSet("foo[3-4]"), NodeSet("foo[5-6]")), tuple(nodeset.split(3))) # Check limit results nodeset = NodeSet("bar[2-4]") for i in (3, 4): self.assertEqual((NodeSet("bar2"), NodeSet("bar3"), NodeSet("bar4")), tuple(nodeset.split(i))) def testAdd(self): """test NodeSet add()""" nodeset = NodeSet() nodeset.add("green") self.assertEqual(len(nodeset), 1) self.assertEqual(str(nodeset), "green") self.assertEqual(nodeset[0], "green") nodeset = NodeSet() nodeset.add("green35") self.assertEqual(len(nodeset), 1) self.assertEqual(str(nodeset), "green35") self.assertEqual(nodeset[0], "green35") nodeset = NodeSet() nodeset.add("green[3,5-46]") self.assertEqual(len(nodeset), 43) self.assertEqual(nodeset[0], "green3") nodeset = NodeSet() nodeset.add("green[3,5-46],black64,orange[045-148]") self.assertEqual(len(nodeset), 148) self.assertTrue("green5" in nodeset) self.assertTrue("black64" in nodeset) self.assertTrue("orange046" in nodeset) def testAddAdjust(self): """test NodeSet adjusting add()""" # autostep OFF nodeset = NodeSet() nodeset.add("green[1-8/2]") self.assertEqual(str(nodeset), "green[1,3,5,7]") self.assertEqual(len(nodeset), 4) nodeset.add("green[6-17/2]") self.assertEqual(str(nodeset), "green[1,3,5-8,10,12,14,16]") self.assertEqual(len(nodeset), 10) # autostep ON nodeset = NodeSet(autostep=2) nodeset.add("green[1-8/2]") self.assertEqual(str(nodeset), "green[1-7/2]") self.assertEqual(len(nodeset), 4) nodeset.add("green[6-17/2]") #self.assertEqual(str(nodeset), "green[1-5/2,6-7,8-16/2]") # <1.9 self.assertEqual(str(nodeset), "green[1-5/2,6-8,10-16/2]") # 1.9+ self.assertEqual(len(nodeset), 10) def testRemove(self): """test NodeSet remove()""" # from empty nodeset nodeset = NodeSet() self.assertEqual(len(nodeset), 0) self.assertRaises(KeyError, nodeset.remove, "tintin23") self.assertRaises(KeyError, nodeset.remove, "tintin[35-36]") nodeset.update("milou36") self.assertEqual(len(nodeset), 1) self.assertRaises(KeyError, nodeset.remove, "tintin23") self.assertTrue("milou36" in nodeset) nodeset.remove("milou36") self.assertEqual(len(nodeset), 0) nodeset.update("milou[36-60,76,95],haddock[1-12],tournesol") self.assertEqual(len(nodeset), 40) nodeset.remove("milou76") self.assertEqual(len(nodeset), 39) nodeset.remove("milou[36-39]") self.assertEqual(len(nodeset), 35) self.assertRaises(KeyError, nodeset.remove, "haddock13") self.assertEqual(len(nodeset), 35) self.assertRaises(KeyError, nodeset.remove, "haddock[1-15]") self.assertEqual(len(nodeset), 35) self.assertRaises(KeyError, nodeset.remove, "tutu") self.assertEqual(len(nodeset), 35) nodeset.remove("tournesol") self.assertEqual(len(nodeset), 34) nodeset.remove("haddock[1-12]") self.assertEqual(len(nodeset), 22) nodeset.remove("milou[40-60,95]") self.assertEqual(len(nodeset), 0) self.assertRaises(KeyError, nodeset.remove, "tournesol") self.assertRaises(KeyError, nodeset.remove, "milou40") # from non-empty nodeset nodeset = NodeSet("haddock[16-3045]") self.assertEqual(len(nodeset), 3030) self.assertRaises(KeyError, nodeset.remove, "haddock15") self.assertTrue("haddock16" in nodeset) self.assertEqual(len(nodeset), 3030) nodeset.remove("haddock[16,18-3044]") self.assertEqual(len(nodeset), 2) self.assertRaises(KeyError, nodeset.remove, "haddock3046") self.assertRaises(KeyError, nodeset.remove, "haddock[16,3060]") self.assertRaises(KeyError, nodeset.remove, "haddock[3045-3046]") self.assertRaises(KeyError, nodeset.remove, "haddock[3045,3049-3051/2]") nodeset.remove("haddock3045") self.assertEqual(len(nodeset), 1) self.assertRaises(KeyError, nodeset.remove, "haddock[3045]") self.assertEqual(len(nodeset), 1) nodeset.remove("haddock17") self.assertEqual(len(nodeset), 0) def testClear(self): """test NodeSet clear()""" nodeset = NodeSet("purple[35-39]") self.assertEqual(len(nodeset), 5) nodeset.clear() self.assertEqual(len(nodeset), 0) def test_contains(self): """test NodeSet contains()""" nodeset = NodeSet() self.assertEqual(len(nodeset), 0) self.assertTrue("foo" not in nodeset) nodeset.update("bar") self.assertEqual(len(nodeset), 1) self.assertEqual(str(nodeset), "bar") self.assertTrue("bar" in nodeset) nodeset.update("foo[20-40]") self.assertTrue("foo" not in nodeset) self.assertTrue("foo39" in nodeset) for node in nodeset: self.assertTrue(node in nodeset) nodeset.update("dark[2000-4000/4]") self.assertTrue("dark3000" in nodeset) self.assertTrue("dark3002" not in nodeset) for node in nodeset: self.assertTrue(node in nodeset) nodeset = NodeSet("scale[0-10000]") self.assertTrue("black64" not in nodeset) self.assertTrue("scale9346" in nodeset) nodeset = NodeSet("scale[0-10000]", autostep=2) self.assertTrue("scale9346" in nodeset[::2]) self.assertTrue("scale9347" not in nodeset[::2]) # nD nodeset = NodeSet("scale[0-1000]p[1,3]") self.assertTrue("black300p2" not in nodeset) self.assertTrue("scale333p3" in nodeset) self.assertTrue("scale333p1" in nodeset) nodeset = NodeSet("scale[0-1000]p[1,3]", autostep=2) self.assertEqual(str(nodeset), "scale[0-1000]p[1-3/2]") nhalf = nodeset[::2] self.assertEqual(str(nhalf), "scale[0-1000]p1") self.assertTrue("scale242p1" in nhalf) self.assertTrue("scale346p1" in nhalf) def testContainsUsingPadding(self): """test NodeSet contains() when using padding""" nodeset = NodeSet("white[001,030]") nodeset.add("white113") self.assertFalse(NodeSet("white30") in nodeset) self.assertTrue(NodeSet("white030") in nodeset) # case: nodeset without padding info is compared to a # padding-initialized range self.assertTrue(NodeSet("white113") in nodeset) self.assertTrue(NodeSet("white[001,113]") in nodeset) self.assertTrue(NodeSet("gene113") in NodeSet("gene[001,030,113]")) self.assertFalse(NodeSet("gene0113") in NodeSet("gene[001,030,113]")) self.assertTrue(NodeSet("gene0113") in NodeSet("gene[0001,0030,0113]")) self.assertTrue(NodeSet("gene113") in NodeSet("gene[098-113]")) self.assertFalse(NodeSet("gene0113") in NodeSet("gene[098-113]")) self.assertTrue(NodeSet("gene0113") in NodeSet("gene[0098-0113]")) # case: len(str(ielem)) >= rgpad nodeset = NodeSet("white[001,099]") nodeset.add("white100") nodeset.add("white1000") self.assertTrue(NodeSet("white100") in nodeset) self.assertFalse(NodeSet("white0100") in nodeset) self.assertTrue(NodeSet("white1000") in nodeset) def test_issuperset(self): """test NodeSet issuperset()""" nodeset = NodeSet("tronic[0036-1630]") self.assertEqual(len(nodeset), 1595) self.assertTrue(nodeset.issuperset("tronic[0036-1630]")) self.assertTrue(nodeset.issuperset("tronic[0140-0200]")) self.assertTrue(nodeset.issuperset(NodeSet("tronic[0140-0200]"))) self.assertTrue(nodeset.issuperset("tronic0070")) self.assertFalse(nodeset.issuperset("tronic0034")) # check padding issue - fixed since 1.9 self.assertFalse(nodeset.issuperset("tronic36")) # used to be true < 1.9 self.assertFalse(nodeset.issuperset("tronic[36-40]")) # same self.assertFalse(nodeset.issuperset(NodeSet("tronic[36-40]"))) # same self.assertTrue(nodeset.issuperset(NodeSet("tronic[0036-0040]"))) # check gt self.assertTrue(nodeset > NodeSet("tronic[0100-0200]")) self.assertFalse(nodeset > NodeSet("tronic[0036-1630]")) self.assertFalse(nodeset > NodeSet("tronic[0036-1631]")) self.assertTrue(nodeset >= NodeSet("tronic[0100-0200]")) self.assertTrue(nodeset >= NodeSet("tronic[0036-1630]")) self.assertFalse(nodeset >= NodeSet("tronic[0036-1631]")) # multiple patterns case nodeset = NodeSet("tronic[0036-1630],lounge[20-660/2]") self.assertTrue(nodeset > NodeSet("tronic[0100-0200]")) self.assertTrue(nodeset > NodeSet("lounge[36-400/2]")) self.assertTrue(nodeset.issuperset(NodeSet("lounge[36-400/2]," "tronic[0100-0660]"))) self.assertTrue(nodeset > NodeSet("lounge[36-400/2],tronic[0100-0660]")) self._assertNS("lounge[36-400/2],tronic[0100-660]", NodeSetParseRangeError) def test_issubset(self): """test NodeSet issubset()""" nodeset = NodeSet("artcore[3-999]") self.assertEqual(len(nodeset), 997) self.assertTrue(nodeset.issubset("artcore[3-999]")) self.assertTrue(nodeset.issubset("artcore[1-1000]")) self.assertFalse(nodeset.issubset("artcore[350-427]")) # check lt self.assertTrue(nodeset < NodeSet("artcore[2-32000]")) self.assertTrue(nodeset < NodeSet("artcore[2-32000],lounge[35-65/2]")) self.assertFalse(nodeset < NodeSet("artcore[3-999]")) self.assertFalse(nodeset < NodeSet("artcore[3-980]")) self.assertFalse(nodeset < NodeSet("artcore[2-998]")) self.assertTrue(nodeset <= NodeSet("artcore[2-32000]")) self.assertTrue(nodeset <= NodeSet("artcore[2-32000],lounge[35-65/2]")) self.assertTrue(nodeset <= NodeSet("artcore[3-999]")) self.assertFalse(nodeset <= NodeSet("artcore[3-980]")) self.assertFalse(nodeset <= NodeSet("artcore[2-998]")) self.assertEqual(len(nodeset), 997) # check padding issues - fixed since 1.9 self.assertFalse(nodeset.issubset("artcore[0001-1000]")) # was true < 1.9 self.assertFalse(nodeset.issubset("artcore30")) self.assertFalse(nodeset.issubset("artcore030")) self.assertFalse(nodeset.issubset("artcore0030")) # multiple patterns case nodeset = NodeSet("tronic[0036-1630],lounge[20-660/2]") self.assertTrue(nodeset < NodeSet("tronic[0036-1630],lounge[20-662/2]")) self.assertTrue(nodeset < NodeSet("tronic[0035-1630],lounge[20-660/2]")) self.assertFalse(nodeset < NodeSet("tronic[0035-1630],lounge[22-660/2]")) self.assertTrue(nodeset < NodeSet("tronic[0036-1630],lounge[20-660/2],artcore[034-070]")) self.assertTrue(nodeset < NodeSet("tronic[0032-1880],lounge[2-700/2],artcore[039-040]")) self.assertTrue(nodeset.issubset("tronic[0032-1880],lounge[2-700/2],artcore[039-040]")) self.assertTrue(nodeset.issubset(NodeSet("tronic[0032-1880],lounge[2-700/2],artcore[039-040]"))) def testSymmetricDifference(self): """test NodeSet symmetric_difference()""" nsstr = "red[34-55,76-249,300-403],blue,green" nodeset = NodeSet(nsstr) self.assertEqual(len(nodeset), 302) nsstr2 = "red[32-57,72-249,300-341],blue,yellow" nodeset2 = NodeSet(nsstr2) self.assertEqual(len(nodeset2), 248) inodeset = nodeset.symmetric_difference(nodeset2) # originals should not change self.assertEqual(len(nodeset), 302) self.assertEqual(len(nodeset2), 248) self.assertEqual(str(nodeset), "blue,green,red[34-55,76-249,300-403]") self.assertEqual(str(nodeset2), "blue,red[32-57,72-249,300-341],yellow") # result self.assertEqual(len(inodeset), 72) self.assertEqual(str(inodeset), "green,red[32-33,56-57,72-75,342-403],yellow") def testSymmetricDifferenceUpdate(self): """test NodeSet symmetric_difference_update()""" nodeset = NodeSet("artcore[3-999]") self.assertEqual(len(nodeset), 997) nodeset.symmetric_difference_update("artcore[1-2000]") self.assertEqual(len(nodeset), 1003) self.assertEqual(str(nodeset), "artcore[1-2,1000-2000]") nodeset = NodeSet("artcore[3-999],lounge") self.assertEqual(len(nodeset), 998) nodeset.symmetric_difference_update("artcore[1-2000]") self.assertEqual(len(nodeset), 1004) self.assertEqual(str(nodeset), "artcore[1-2,1000-2000],lounge") nodeset = NodeSet("artcore[3-999],lounge") self.assertEqual(len(nodeset), 998) nodeset.symmetric_difference_update("artcore[1-2000],lounge") self.assertEqual(len(nodeset), 1003) self.assertEqual(str(nodeset), "artcore[1-2,1000-2000]") nodeset = NodeSet("artcore[3-999],lounge") self.assertEqual(len(nodeset), 998) nodeset2 = NodeSet("artcore[1-2000],lounge") nodeset.symmetric_difference_update(nodeset2) self.assertEqual(len(nodeset), 1003) self.assertEqual(str(nodeset), "artcore[1-2,1000-2000]") self.assertEqual(len(nodeset2), 2001) # check const argument nodeset.symmetric_difference_update("artcore[1-2000],lounge") self.assertEqual(len(nodeset), 998) self.assertEqual(str(nodeset), "artcore[3-999],lounge") def testOperatorSymmetricDifference(self): """test NodeSet symmetric_difference() and ^ operator""" nodeset = NodeSet("artcore[3-999]") self.assertEqual(len(nodeset), 997) result = nodeset.symmetric_difference("artcore[1-2000]") self.assertEqual(len(result), 1003) self.assertEqual(str(result), "artcore[1-2,1000-2000]") self.assertEqual(len(nodeset), 997) # test ^ operator nodeset = NodeSet("artcore[3-999]") self.assertEqual(len(nodeset), 997) nodeset2 = NodeSet("artcore[1-2000]") result = nodeset ^ nodeset2 self.assertEqual(len(result), 1003) self.assertEqual(str(result), "artcore[1-2,1000-2000]") self.assertEqual(len(nodeset), 997) self.assertEqual(len(nodeset2), 2000) # check that n ^ n returns empty NodeSet nodeset = NodeSet("lounge[3-999]") self.assertEqual(len(nodeset), 997) result = nodeset ^ nodeset self.assertEqual(len(result), 0) def testBinarySanityCheck(self): """test NodeSet binary sanity check""" ns1 = NodeSet("1-5") ns2 = "4-6" self.assertRaises(TypeError, ns1.__gt__, ns2) self.assertRaises(TypeError, ns1.__lt__, ns2) def testBinarySanityCheckNotImplementedSubtle(self): """test NodeSet binary sanity check (NotImplemented subtle)""" ns1 = NodeSet("1-5") ns2 = "4-6" self.assertEqual(ns1.__and__(ns2), NotImplemented) self.assertEqual(ns1.__or__(ns2), NotImplemented) self.assertEqual(ns1.__sub__(ns2), NotImplemented) self.assertEqual(ns1.__xor__(ns2), NotImplemented) # Should implicitly raises TypeError if the real operator # version is invoked. To test that, we perform a manual check # as an additional function would be needed to check with # assertRaises(): good_error = False try: ns3 = ns1 & ns2 except TypeError: good_error = True self.assertTrue(good_error, "TypeError not raised for &") good_error = False try: ns3 = ns1 | ns2 except TypeError: good_error = True self.assertTrue(good_error, "TypeError not raised for |") good_error = False try: ns3 = ns1 - ns2 except TypeError: good_error = True self.assertTrue(good_error, "TypeError not raised for -") good_error = False try: ns3 = ns1 ^ ns2 except TypeError: good_error = True self.assertTrue(good_error, "TypeError not raised for ^") def testIsSubSetError(self): """test NodeSet issubset type error""" ns1 = NodeSet("1-5") ns2 = 4 self.assertRaises(TypeError, ns1.issubset, ns2) def testExpandFunction(self): """test NodeSet expand() utility function""" self.assertEqual(expand("purple[1-3]"), ["purple1", "purple2", "purple3"]) def testFoldFunction(self): """test NodeSet fold() utility function""" self.assertEqual(fold("purple1,purple2,purple3"), "purple[1-3]") def testEquality(self): """test NodeSet equality""" ns0_1 = NodeSet() ns0_2 = NodeSet() self.assertEqual(ns0_1, ns0_2) ns1 = NodeSet("roma[50-99]-ipmi,cors[113,115-117,130,166-172]," "cws-tigrou,tigrou3") ns2 = NodeSet("roma[50-99]-ipmi,cors[113,115-117,130,166-172]," "cws-tigrou,tigrou3") self.assertEqual(ns1, ns2) ns3 = NodeSet("cws-tigrou,tigrou3,cors[113,115-117,166-172]," "roma[50-99]-ipmi,cors130") self.assertEqual(ns1, ns3) ns4 = NodeSet("roma[50-99]-ipmi,cors[113,115-117,130,166-171]," "cws-tigrou,tigrou[3-4]") self.assertNotEqual(ns1, ns4) def testIterOrder(self): """test NodeSet nodes name order in iter and str""" ns_b = NodeSet("bcluster25") ns_c = NodeSet("ccluster12") ns_a1 = NodeSet("acluster4") ns_a2 = NodeSet("acluster39") ns_a3 = NodeSet("acluster41") ns = ns_c | ns_a1 | ns_b | ns_a2 | ns_a3 self.assertEqual(str(ns), "acluster[4,39,41],bcluster25,ccluster12") nodelist = list(iter(ns)) self.assertEqual(nodelist, ['acluster4', 'acluster39', 'acluster41', 'bcluster25', 'ccluster12']) def test_nsiter(self): """test NodeSet.nsiter() iterator""" ns1 = NodeSet("roma[50-61]-ipmi,cors[113,115-117,130,166-169]," "cws-tigrou,tigrou3") self.assertEqual(list(ns1), ['cors113', 'cors115', 'cors116', 'cors117', 'cors130', 'cors166', 'cors167', 'cors168', 'cors169', 'cws-tigrou', 'roma50-ipmi', 'roma51-ipmi', 'roma52-ipmi', 'roma53-ipmi', 'roma54-ipmi', 'roma55-ipmi', 'roma56-ipmi', 'roma57-ipmi', 'roma58-ipmi', 'roma59-ipmi', 'roma60-ipmi', 'roma61-ipmi', 'tigrou3']) self.assertEqual(list(ns1), [str(ns) for ns in ns1.nsiter()]) # Ticket #286 - broken nsiter() in 1.7 with nD + 0-padding ns1 = NodeSet("n0c01") self.assertEqual(list(ns1), ['n0c01']) self.assertEqual(list(ns1), [str(ns) for ns in ns1.nsiter()]) ns1 = NodeSet("n0c01,n1c01") self.assertEqual(list(ns1), ['n0c01', 'n1c01']) self.assertEqual(list(ns1), [str(ns) for ns in ns1.nsiter()]) def test_contiguous(self): """test NodeSet.contiguous() iterator""" ns1 = NodeSet("cors,roma[50-61]-ipmi,cors[113,115-117,130,166-169]," "cws-tigrou,tigrou3") self.assertEqual(['cors', 'cors113', 'cors[115-117]', 'cors130', 'cors[166-169]', 'cws-tigrou', 'roma[50-61]-ipmi', 'tigrou3'], [str(ns) for ns in ns1.contiguous()]) # check if NodeSet instances returned by contiguous() iterator are not # the same testlist = list(ns1.contiguous()) for i in range(len(testlist)): for j in range(i + 1, len(testlist)): self.assertNotEqual(testlist[i], testlist[j]) self.assertNotEqual(id(testlist[i]), id(testlist[j])) def testEqualityMore(self): """test NodeSet equality (more)""" self.assertEqual(NodeSet(), NodeSet()) ns1 = NodeSet("nodealone") ns2 = NodeSet("nodealone") self.assertEqual(ns1, ns2) ns1 = NodeSet("clu3,clu[4-9],clu11") ns2 = NodeSet("clu[3-9,11]") self.assertEqual(ns1, ns2) if ns1 == None: self.fail("ns1 == None succeeded") if ns1 != None: pass else: self.fail("ns1 != None failed") def testNodeSetNone(self): """test NodeSet methods behavior with None argument""" nodeset = NodeSet(None) self.assertEqual(len(nodeset), 0) self.assertEqual(list(nodeset), []) nodeset.update(None) self.assertEqual(list(nodeset), []) nodeset.intersection_update(None) self.assertEqual(list(nodeset), []) nodeset.difference_update(None) self.assertEqual(list(nodeset), []) nodeset.symmetric_difference_update(None) self.assertEqual(list(nodeset), []) n = nodeset.union(None) self.assertEqual(list(n), []) self.assertEqual(len(n), 0) n = nodeset.intersection(None) self.assertEqual(list(n), []) n = nodeset.difference(None) self.assertEqual(list(n), []) n = nodeset.symmetric_difference(None) self.assertEqual(list(n), []) nodeset = NodeSet("abc[3,6-89],def[3-98,104,128-133]") self.assertEqual(len(nodeset), 188) nodeset.update(None) self.assertEqual(len(nodeset), 188) nodeset.intersection_update(None) self.assertEqual(len(nodeset), 0) self.assertEqual(list(nodeset), []) nodeset = NodeSet("abc[3,6-89],def[3-98,104,128-133]") self.assertEqual(len(nodeset), 188) nodeset.difference_update(None) self.assertEqual(len(nodeset), 188) nodeset.symmetric_difference_update(None) self.assertEqual(len(nodeset), 188) n = nodeset.union(None) self.assertEqual(len(nodeset), 188) n = nodeset.intersection(None) self.assertEqual(list(n), []) self.assertEqual(len(n), 0) n = nodeset.difference(None) self.assertEqual(len(n), 188) n = nodeset.symmetric_difference(None) self.assertEqual(len(n), 188) self.assertFalse(n.issubset(None)) self.assertTrue(n.issuperset(None)) n = NodeSet(None) n.clear() self.assertEqual(len(n), 0) def testCopy(self): """test NodeSet.copy()""" nodeset = NodeSet("zclu[115-117,130,166-170],glycine[68,4780-4999]") self.assertEqual(str(nodeset), "glycine[68,4780-4999],zclu[115-117,130,166-170]") nodeset2 = nodeset.copy() nodeset3 = nodeset.copy() self.assertEqual(nodeset, nodeset2) # content equality self.assertTrue(isinstance(nodeset, NodeSet)) self.assertTrue(isinstance(nodeset2, NodeSet)) self.assertTrue(isinstance(nodeset3, NodeSet)) nodeset2.remove("glycine68") self.assertEqual(len(nodeset), len(nodeset2) + 1) self.assertNotEqual(nodeset, nodeset2) self.assertEqual(str(nodeset2), "glycine[4780-4999],zclu[115-117,130,166-170]") self.assertEqual(str(nodeset), "glycine[68,4780-4999],zclu[115-117,130,166-170]") nodeset2.add("glycine68") self.assertEqual(str(nodeset2), "glycine[68,4780-4999],zclu[115-117,130,166-170]") self.assertEqual(nodeset, nodeset3) nodeset3.update(NodeSet("zclu118")) self.assertNotEqual(nodeset, nodeset3) self.assertEqual(len(nodeset) + 1, len(nodeset3)) self.assertEqual(str(nodeset), "glycine[68,4780-4999],zclu[115-117,130,166-170]") self.assertEqual(str(nodeset3), "glycine[68,4780-4999],zclu[115-118,130,166-170]") # test copy with single nodes nodeset = NodeSet("zclu[115-117,130,166-170],foo,bar," "glycine[68,4780-4999]") nodeset2 = nodeset.copy() self.assertEqual(nodeset, nodeset2) # content equality # same with NodeSetBase nodeset = NodeSetBase("foobar", None) nodeset2 = nodeset.copy() self.assertEqual(nodeset, nodeset2) # content equality # unpickling tests; generate data with: # ns = NodeSet("bar[050-150,502-599],foo[1,4-50,80-100]") # print(binascii.b2a_base64(pickle.dumps(ns))) def test_unpickle_v1_3_py24(self): """test NodeSet unpickling (against v1.3/py24)""" nodeset = pickle.loads(binascii.a2b_base64("gAJjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApxACmBcQF9cQIoVQdfbGVuZ3RocQNLAFUJX3BhdHRlcm5zcQR9cQUoVQh5ZWxsb3clc3EGKGNDbHVzdGVyU2hlbGwuTm9kZVNldApSYW5nZVNldApxB29xCH1xCShoA0sBVQlfYXV0b3N0ZXBxCkdUskmtJZTDfVUHX3Jhbmdlc3ELXXEMKEsESwRLAUsAdHENYXViVQZibHVlJXNxDihoB29xD31xEChoA0sIaApHVLJJrSWUw31oC11xESgoSwZLCksBSwB0cRIoSw1LDUsBSwB0cRMoSw9LD0sBSwB0cRQoSxFLEUsBSwB0cRVldWJVB2dyZWVuJXNxFihoB29xF31xGChoA0tlaApHVLJJrSWUw31oC11xGShLAEtkSwFLAHRxGmF1YlUDcmVkcRtOdWgKTnViLg==")) self.assertEqual(nodeset, NodeSet("blue[6-10,13,15,17],green[0-100],red,yellow4")) self.assertEqual(str(nodeset), "blue[6-10,13,15,17],green[0-100],red,yellow4") self.assertEqual(len(nodeset), 111) self.assertEqual(nodeset[0], "blue6") self.assertEqual(nodeset[1], "blue7") self.assertEqual(nodeset[-1], "yellow4") # unpickle_v1_4_py24 : unpickling fails as v1.4 does not have slice # pickling workaround def test_unpickle_v1_3_py26(self): """test NodeSet unpickling (against v1.3/py26)""" nodeset = pickle.loads(binascii.a2b_base64("gAJjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApxACmBcQF9cQIoVQdfbGVuZ3RocQNLAFUJX3BhdHRlcm5zcQR9cQUoVQh5ZWxsb3clc3EGKGNDbHVzdGVyU2hlbGwuTm9kZVNldApSYW5nZVNldApxB29xCH1xCShoA0sBVQlfYXV0b3N0ZXBxCkdUskmtJZTDfVUHX3Jhbmdlc3ELXXEMKEsESwRLAUsAdHENYXViVQZibHVlJXNxDihoB29xD31xEChoA0sIaApHVLJJrSWUw31oC11xESgoSwZLCksBSwB0cRIoSw1LDUsBSwB0cRMoSw9LD0sBSwB0cRQoSxFLEUsBSwB0cRVldWJVB2dyZWVuJXNxFihoB29xF31xGChoA0tlaApHVLJJrSWUw31oC11xGShLAEtkSwFLAHRxGmF1YlUDcmVkcRtOdWgKTnViLg==")) self.assertEqual(nodeset, NodeSet("blue[6-10,13,15,17],green[0-100],red,yellow4")) self.assertEqual(str(nodeset), "blue[6-10,13,15,17],green[0-100],red,yellow4") self.assertEqual(len(nodeset), 111) self.assertEqual(nodeset[0], "blue6") self.assertEqual(nodeset[1], "blue7") self.assertEqual(nodeset[-1], "yellow4") # unpickle_v1_4_py24 : unpickling fails as v1.4 does not have slice # pickling workaround def test_unpickle_v1_4_py26(self): """test NodeSet unpickling (against v1.4/py26)""" nodeset = pickle.loads(binascii.a2b_base64("gAJjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApxACmBcQF9cQIoVQdfbGVuZ3RocQNLAFUJX3BhdHRlcm5zcQR9cQUoVQh5ZWxsb3clc3EGKGNDbHVzdGVyU2hlbGwuTm9kZVNldApSYW5nZVNldApxB29xCH1xCihoA0sBVQlfYXV0b3N0ZXBxC0dUskmtJZTDfVUHX3Jhbmdlc3EMXXENY19fYnVpbHRpbl9fCnNsaWNlCnEOSwRLBUsBh3EPUnEQSwCGcRFhVQhfdmVyc2lvbnESSwJ1YlUGYmx1ZSVzcRMoaAdvcRR9cRUoaANLCGgLR1SySa0llMN9aAxdcRYoaA5LBksLSwGHcRdScRhLAIZxGWgOSw1LDksBh3EaUnEbSwCGcRxoDksPSxBLAYdxHVJxHksAhnEfaA5LEUsSSwGHcSBScSFLAIZxImVoEksCdWJVB2dyZWVuJXNxIyhoB29xJH1xJShoA0tlaAtHVLJJrSWUw31oDF1xJmgOSwBLZUsBh3EnUnEoSwCGcSlhaBJLAnViVQNyZWRxKk51aAtOdWIu")) self.assertEqual(nodeset, NodeSet("blue[6-10,13,15,17],green[0-100],red,yellow4")) self.assertEqual(str(nodeset), "blue[6-10,13,15,17],green[0-100],red,yellow4") self.assertEqual(len(nodeset), 111) self.assertEqual(nodeset[0], "blue6") self.assertEqual(nodeset[1], "blue7") self.assertEqual(nodeset[-1], "yellow4") def test_unpickle_v1_5_py24(self): """test NodeSet unpickling (against v1.5/py24)""" nodeset = pickle.loads(binascii.a2b_base64("gAJjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApxACmBcQF9cQIoVQdfbGVuZ3RocQNLAFUJX3BhdHRlcm5zcQR9cQUoVQh5ZWxsb3clc3EGKGNDbHVzdGVyU2hlbGwuTm9kZVNldApSYW5nZVNldApxB29xCH1xCihoA0sBVQlfYXV0b3N0ZXBxC0dUskmtJZTDfVUHX3Jhbmdlc3EMXXENSwRLBUsBh3EOSwCGcQ9hVQhfdmVyc2lvbnEQSwJ1YlUGYmx1ZSVzcREoaAdvcRJ9cRMoaANLCGgLR1SySa0llMN9aAxdcRQoSwZLC0sBh3EVSwCGcRZLDUsOSwGHcRdLAIZxGEsPSxBLAYdxGUsAhnEaSxFLEksBh3EbSwCGcRxlaBBLAnViVQdncmVlbiVzcR0oaAdvcR59cR8oaANLZWgLR1SySa0llMN9aAxdcSBLAEtlSwGHcSFLAIZxImFoEEsCdWJVA3JlZHEjTnVoC051Yi4=")) self.assertEqual(nodeset, NodeSet("blue[6-10,13,15,17],green[0-100],red,yellow4")) self.assertEqual(str(nodeset), "blue[6-10,13,15,17],green[0-100],red,yellow4") self.assertEqual(len(nodeset), 111) self.assertEqual(nodeset[0], "blue6") self.assertEqual(nodeset[1], "blue7") self.assertEqual(nodeset[-1], "yellow4") def test_unpickle_v1_5_py26(self): """test NodeSet unpickling (against v1.5/py26)""" nodeset = pickle.loads(binascii.a2b_base64("gAJjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApxACmBcQF9cQIoVQdfbGVuZ3RocQNLAFUJX3BhdHRlcm5zcQR9cQUoVQh5ZWxsb3clc3EGKGNDbHVzdGVyU2hlbGwuTm9kZVNldApSYW5nZVNldApxB29xCH1xCihoA0sBVQlfYXV0b3N0ZXBxC0dUskmtJZTDfVUHX3Jhbmdlc3EMXXENY19fYnVpbHRpbl9fCnNsaWNlCnEOSwRLBUsBh3EPUnEQSwCGcRFhVQhfdmVyc2lvbnESSwJ1YlUGYmx1ZSVzcRMoaAdvcRR9cRUoaANLCGgLR1SySa0llMN9aAxdcRYoaA5LBksLSwGHcRdScRhLAIZxGWgOSw1LDksBh3EaUnEbSwCGcRxoDksPSxBLAYdxHVJxHksAhnEfaA5LEUsSSwGHcSBScSFLAIZxImVoEksCdWJVB2dyZWVuJXNxIyhoB29xJH1xJShoA0tlaAtHVLJJrSWUw31oDF1xJmgOSwBLZUsBh3EnUnEoSwCGcSlhaBJLAnViVQNyZWRxKk51aAtOdWIu")) self.assertEqual(nodeset, NodeSet("blue[6-10,13,15,17],green[0-100],red,yellow4")) self.assertEqual(str(nodeset), "blue[6-10,13,15,17],green[0-100],red,yellow4") self.assertEqual(len(nodeset), 111) self.assertEqual(nodeset[0], "blue6") self.assertEqual(nodeset[1], "blue7") self.assertEqual(nodeset[-1], "yellow4") def test_unpickle_v1_6_py24(self): """test NodeSet unpickling (against v1.6/py24)""" nodeset = pickle.loads(binascii.a2b_base64("gAJjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApxACmBcQF9cQIoVQdfbGVuZ3RocQNLAFUJX3BhdHRlcm5zcQR9cQUoVQh5ZWxsb3clc3EGY0NsdXN0ZXJTaGVsbC5SYW5nZVNldApSYW5nZVNldApxB1UBNHEIhXEJUnEKfXELKFUHcGFkZGluZ3EMTlUJX2F1dG9zdGVwcQ1HVLJJrSWUw31VCF92ZXJzaW9ucQ5LA3ViVQZibHVlJXNxD2gHVQ02LTEwLDEzLDE1LDE3cRCFcRFScRJ9cRMoaAxOaA1HVLJJrSWUw31oDksDdWJVB2dyZWVuJXNxFGgHVQUwLTEwMHEVhXEWUnEXfXEYKGgMTmgNR1SySa0llMN9aA5LA3ViVQNyZWRxGU51aA1OdWIu")) self.assertEqual(nodeset, NodeSet("blue[6-10,13,15,17],green[0-100],red,yellow4")) self.assertEqual(str(nodeset), "blue[6-10,13,15,17],green[0-100],red,yellow4") self.assertEqual(len(nodeset), 111) self.assertEqual(nodeset[0], "blue6") self.assertEqual(nodeset[1], "blue7") self.assertEqual(nodeset[-1], "yellow4") def test_unpickle_v1_6_py26(self): """test NodeSet unpickling (against v1.6/py26)""" nodeset = pickle.loads(binascii.a2b_base64("gAJjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApxACmBcQF9cQIoVQdfbGVuZ3RocQNLAFUJX3BhdHRlcm5zcQR9cQUoVQh5ZWxsb3clc3EGY0NsdXN0ZXJTaGVsbC5SYW5nZVNldApSYW5nZVNldApxB1UBNHEIhXEJUnEKfXELKFUHcGFkZGluZ3EMTlUJX2F1dG9zdGVwcQ1HVLJJrSWUw31VCF92ZXJzaW9ucQ5LA3ViVQZibHVlJXNxD2gHVQ02LTEwLDEzLDE1LDE3cRCFcRFScRJ9cRMoaAxOaA1HVLJJrSWUw31oDksDdWJVB2dyZWVuJXNxFGgHVQUwLTEwMHEVhXEWUnEXfXEYKGgMTmgNR1SySa0llMN9aA5LA3ViVQNyZWRxGU51aA1OdWIu")) self.assertEqual(nodeset, NodeSet("blue[6-10,13,15,17],green[0-100],red,yellow4")) self.assertEqual(str(nodeset), "blue[6-10,13,15,17],green[0-100],red,yellow4") self.assertEqual(len(nodeset), 111) self.assertEqual(nodeset[0], "blue6") self.assertEqual(nodeset[1], "blue7") self.assertEqual(nodeset[-1], "yellow4") def test_unpickle_v1_7_3_py27(self): """test NodeSet unpickling (against v1.7.3/py27)""" nodeset = pickle.loads(binascii.a2b_base64("Y2NvcHlfcmVnCl9yZWNvbnN0cnVjdG9yCnAwCihjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApwMQpjX19idWlsdGluX18Kb2JqZWN0CnAyCk50cDMKUnA0CihkcDUKUydmb2xkX2F4aXMnCnA2Ck5zUydfbGVuZ3RoJwpwNwpJMApzUydfcGF0dGVybnMnCnA4CihkcDkKUydmb28lcycKcDEwCmNDbHVzdGVyU2hlbGwuUmFuZ2VTZXQKUmFuZ2VTZXQKcDExCihTJzEsNC01MCw4MC0xMDAnCnAxMgp0cDEzClJwMTQKKGRwMTUKUydwYWRkaW5nJwpwMTYKTnNTJ19hdXRvc3RlcCcKcDE3CkYxZSsxMDAKc1MnX3ZlcnNpb24nCnAxOApJMwpzYnNTJ2JhciVzJwpwMTkKZzExCihTJzA1MC0xNTAsNTAyLTU5OScKcDIwCnRwMjEKUnAyMgooZHAyMwpnMTYKSTMKc2cxNwpGMWUrMTAwCnNnMTgKSTMKc2Jzc2cxNwpOc2cxOApJMgpzYi4=")) self.assertEqual(nodeset, NodeSet("foo[1,4-50,80-100],bar[050-150,502-599]")) self.assertEqual(str(nodeset), "bar[050-150,502-599],foo[1,4-50,80-100]") self.assertEqual(len(nodeset), 268) self.assertEqual(nodeset[0], "bar050") self.assertEqual(nodeset[1], "bar051") self.assertEqual(nodeset[-1], "foo100") def test_unpickle_v1_8_4_py27(self): """test NodeSet unpickling (against v1.8.4/py27)""" nodeset = pickle.loads(binascii.a2b_base64("Y2NvcHlfcmVnCl9yZWNvbnN0cnVjdG9yCnAwCihjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApwMQpjX19idWlsdGluX18Kb2JqZWN0CnAyCk50cDMKUnA0CihkcDUKUydmb2xkX2F4aXMnCnA2Ck5zUydfbGVuZ3RoJwpwNwpJMApzUydfcGF0dGVybnMnCnA4CihkcDkKUydmb28lcycKcDEwCmNDbHVzdGVyU2hlbGwuUmFuZ2VTZXQKUmFuZ2VTZXQKcDExCihTJzEsNC01MCw4MC0xMDAnCnAxMgp0cDEzClJwMTQKKGRwMTUKUydwYWRkaW5nJwpwMTYKTnNTJ19hdXRvc3RlcCcKcDE3CkYxZSsxMDAKc1MnX3ZlcnNpb24nCnAxOApJMwpzYnNTJ2JhciVzJwpwMTkKZzExCihTJzA1MC0xNTAsNTAyLTU5OScKcDIwCnRwMjEKUnAyMgooZHAyMwpnMTYKSTMKc2cxNwpGMWUrMTAwCnNnMTgKSTMKc2Jzc2cxNwpOc2cxOApJMgpzYi4=")) self.assertEqual(nodeset, NodeSet("foo[1,4-50,80-100],bar[050-150,502-599]")) self.assertEqual(str(nodeset), "bar[050-150,502-599],foo[1,4-50,80-100]") self.assertEqual(len(nodeset), 268) self.assertEqual(nodeset[0], "bar050") self.assertEqual(nodeset[1], "bar051") self.assertEqual(nodeset[-1], "foo100") def test_pickle_current(self): """test NodeSet pickling (current version)""" dump = pickle.dumps(NodeSet("foo[1-100]")) self.assertNotEqual(dump, None) nodeset = pickle.loads(dump) self.assertEqual(nodeset, NodeSet("foo[1-100]")) self.assertEqual(str(nodeset), "foo[1-100]") self.assertEqual(nodeset[0], "foo1") self.assertEqual(nodeset[1], "foo2") self.assertEqual(nodeset[-1], "foo100") def test_nd_unpickle_v1_6_py26(self): """test NodeSet nD unpickling (against v1.6/py26)""" # Use cases that will test conversion required when using # NodeSet nD (see NodeSet.__setstate__()): # TEST FROM v1.6: NodeSet("foo[1-100]bar[1-10]") nodeset = pickle.loads(binascii.a2b_base64("Y2NvcHlfcmVnCl9yZWNvbnN0cnVjdG9yCnAwCihjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApwMQpjX19idWlsdGluX18Kb2JqZWN0CnAyCk50cDMKUnA0CihkcDUKUydfbGVuZ3RoJwpwNgpJMApzUydfcGF0dGVybnMnCnA3CihkcDgKUydmb28lc2JhclsxLTEwXScKcDkKY0NsdXN0ZXJTaGVsbC5SYW5nZVNldApSYW5nZVNldApwMTAKKFMnMS0xMDAnCnAxMQp0cDEyClJwMTMKKGRwMTQKUydwYWRkaW5nJwpwMTUKTnNTJ19hdXRvc3RlcCcKcDE2CkYxZSsxMDAKc1MnX3ZlcnNpb24nCnAxNwpJMwpzYnNzZzE2Ck5zYi4=\n")) self.assertEqual(str(nodeset), str(NodeSet("foo[1-100]bar[1-10]"))) self.assertEqual(nodeset, NodeSet("foo[1-100]bar[1-10]")) self.assertEqual(len(nodeset), 1000) self.assertEqual(nodeset[0], "foo1bar1") self.assertEqual(nodeset[1], "foo1bar2") self.assertEqual(nodeset[-1], "foo100bar10") # TEST FROM v1.6: NodeSet("foo[1-100]bar3,foo[1-100]bar7,foo[1-100]bar12") nodeset = pickle.loads(binascii.a2b_base64("Y2NvcHlfcmVnCl9yZWNvbnN0cnVjdG9yCnAwCihjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApwMQpjX19idWlsdGluX18Kb2JqZWN0CnAyCk50cDMKUnA0CihkcDUKUydfbGVuZ3RoJwpwNgpJMApzUydfcGF0dGVybnMnCnA3CihkcDgKUydmb28lc2JhcjEyJwpwOQpjQ2x1c3RlclNoZWxsLlJhbmdlU2V0ClJhbmdlU2V0CnAxMAooUycxLTEwMCcKcDExCnRwMTIKUnAxMwooZHAxNApTJ3BhZGRpbmcnCnAxNQpOc1MnX2F1dG9zdGVwJwpwMTYKRjFlKzEwMApzUydfdmVyc2lvbicKcDE3CkkzCnNic1MnZm9vJXNiYXIzJwpwMTgKZzEwCihTJzEtMTAwJwpwMTkKdHAyMApScDIxCihkcDIyCmcxNQpOc2cxNgpGMWUrMTAwCnNnMTcKSTMKc2JzUydmb28lc2JhcjcnCnAyMwpnMTAKKFMnMS0xMDAnCnAyNAp0cDI1ClJwMjYKKGRwMjcKZzE1Ck5zZzE2CkYxZSsxMDAKc2cxNwpJMwpzYnNzZzE2Ck5zYi4=\n")) self.assertEqual(str(nodeset), str(NodeSet("foo[1-100]bar[3,7,12]"))) self.assertEqual(nodeset, NodeSet("foo[1-100]bar[3,7,12]")) self.assertEqual(len(nodeset), 300) self.assertEqual(nodeset[0], "foo1bar3") self.assertEqual(nodeset[1], "foo1bar7") self.assertEqual(nodeset[-1], "foo100bar12") # TEST FROM v1.6: NodeSet("foo1bar3,foo2bar4,foo[6-20]bar3") nodeset = pickle.loads(binascii.a2b_base64("Y2NvcHlfcmVnCl9yZWNvbnN0cnVjdG9yCnAwCihjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApwMQpjX19idWlsdGluX18Kb2JqZWN0CnAyCk50cDMKUnA0CihkcDUKUydfbGVuZ3RoJwpwNgpJMApzUydfcGF0dGVybnMnCnA3CihkcDgKUydmb28lc2JhcjMnCnA5CmNDbHVzdGVyU2hlbGwuUmFuZ2VTZXQKUmFuZ2VTZXQKcDEwCihTJzEsNi0yMCcKcDExCnRwMTIKUnAxMwooZHAxNApTJ3BhZGRpbmcnCnAxNQpOc1MnX2F1dG9zdGVwJwpwMTYKRjFlKzEwMApzUydfdmVyc2lvbicKcDE3CkkzCnNic1MnZm9vJXNiYXI0JwpwMTgKZzEwCihTJzInCnAxOQp0cDIwClJwMjEKKGRwMjIKZzE1Ck5zZzE2CkYxZSsxMDAKc2cxNwpJMwpzYnNzZzE2Ck5zYi4=\n")) self.assertEqual(str(nodeset), str(NodeSet("foo[1,6-20]bar3,foo2bar4"))) self.assertEqual(nodeset, NodeSet("foo[1,6-20]bar3,foo2bar4")) self.assertEqual(len(nodeset), 17) self.assertEqual(nodeset[0], "foo1bar3") self.assertEqual(nodeset[1], "foo6bar3") self.assertEqual(nodeset[-1], "foo2bar4") # TEST FROM v1.6: NodeSet("foo[1-100]bar4,foo[1-100]bar,foo[1-20],bar,foo101bar4") nodeset = pickle.loads(binascii.a2b_base64("Y2NvcHlfcmVnCl9yZWNvbnN0cnVjdG9yCnAwCihjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApwMQpjX19idWlsdGluX18Kb2JqZWN0CnAyCk50cDMKUnA0CihkcDUKUydfbGVuZ3RoJwpwNgpJMApzUydfcGF0dGVybnMnCnA3CihkcDgKUydmb28lcycKcDkKY0NsdXN0ZXJTaGVsbC5SYW5nZVNldApSYW5nZVNldApwMTAKKFMnMS0yMCcKcDExCnRwMTIKUnAxMwooZHAxNApTJ3BhZGRpbmcnCnAxNQpOc1MnX2F1dG9zdGVwJwpwMTYKRjFlKzEwMApzUydfdmVyc2lvbicKcDE3CkkzCnNic1MnZm9vJXNiYXInCnAxOApnMTAKKFMnMS0xMDAnCnAxOQp0cDIwClJwMjEKKGRwMjIKZzE1Ck5zZzE2CkYxZSsxMDAKc2cxNwpJMwpzYnNTJ2ZvbyVzYmFyNCcKcDIzCmcxMAooUycxLTEwMScKcDI0CnRwMjUKUnAyNgooZHAyNwpnMTUKTnNnMTYKRjFlKzEwMApzZzE3CkkzCnNic1MnYmFyJwpwMjgKTnNzZzE2Ck5zYi4=\n")) self.assertEqual(str(nodeset), str(NodeSet("bar,foo[1-20],foo[1-100]bar," "foo[1-101]bar4"))) self.assertEqual(nodeset, NodeSet("bar,foo[1-20],foo[1-100]bar,foo[1-101]bar4")) self.assertEqual(len(nodeset), 222) self.assertEqual(nodeset[0], "bar") self.assertEqual(nodeset[1], "foo1") self.assertEqual(nodeset[-1], "foo101bar4") def test_nd_unpickle_v1_7_3_py27(self): """test NodeSet nD unpickling (against v1.7.3/py27)""" # TEST FROM v1.7.3: NodeSet("foo[1-100]bar[00001-00010]") nodeset = pickle.loads(binascii.a2b_base64("Y2NvcHlfcmVnCl9yZWNvbnN0cnVjdG9yCnAwCihjQ2x1c3RlclNoZWxsLk5vZGVTZXQKTm9kZVNldApwMQpjX19idWlsdGluX18Kb2JqZWN0CnAyCk50cDMKUnA0CihkcDUKUydmb2xkX2F4aXMnCnA2Ck5zUydfbGVuZ3RoJwpwNwpJMApzUydfcGF0dGVybnMnCnA4CihkcDkKUydmb28lc2JhciVzJwpwMTAKZzAKKGNDbHVzdGVyU2hlbGwuUmFuZ2VTZXQKUmFuZ2VTZXRORApwMTEKZzIKTnRwMTIKUnAxMwooZHAxNApTJ19tdWx0aXZhcl9oaW50JwpwMTUKSTAwCnNTJ192ZWNsaXN0JwpwMTYKKGxwMTcKKGxwMTgKY0NsdXN0ZXJTaGVsbC5SYW5nZVNldApSYW5nZVNldApwMTkKKFMnMS0xMDAnCnAyMAp0cDIxClJwMjIKKGRwMjMKUydwYWRkaW5nJwpwMjQKTnNTJ19hdXRvc3RlcCcKcDI1CkYxZSsxMDAKc1MnX3ZlcnNpb24nCnAyNgpJMwpzYmFnMTkKKFMnMDAwMDEtMDAwMTAnCnAyNwp0cDI4ClJwMjkKKGRwMzAKZzI0Ckk1CnNnMjUKRjFlKzEwMApzZzI2CkkzCnNiYWFzZzI1CkYxZSsxMDAKc1MnX2RpcnR5JwpwMzEKSTAwCnNic3NnMjUKTnNnMjYKSTIKc2Iu")) self.assertEqual(str(nodeset), str(NodeSet("foo[1-100]bar[00001-00010]"))) self.assertEqual(nodeset, NodeSet("foo[1-100]bar[00001-00010]")) self.assertEqual(len(nodeset), 1000) self.assertEqual(nodeset[0], "foo1bar00001") self.assertEqual(nodeset[1], "foo1bar00002") self.assertEqual(nodeset[-1], "foo100bar00010") def test_nd_pickle_current(self): """test NodeSet nD pickling (current version)""" dump = pickle.dumps(NodeSet("foo[1-100]bar[1-10]")) self.assertNotEqual(dump, None) nodeset = pickle.loads(dump) self.assertEqual(nodeset, NodeSet("foo[1-100]bar[1-10]")) self.assertEqual(str(nodeset), "foo[1-100]bar[1-10]") self.assertEqual(nodeset[0], "foo1bar1") self.assertEqual(nodeset[1], "foo1bar2") self.assertEqual(nodeset[-1], "foo100bar10") dump = pickle.dumps(NodeSet("foo[1-100]bar4,foo[1-100]bar,foo[1-20]," "bar,foo101bar4")) self.assertNotEqual(dump, None) nodeset = pickle.loads(dump) self.assertEqual(nodeset, NodeSet("bar,foo[1-20],foo[1-100]bar,foo[1-101]bar4")) self.assertEqual(str(nodeset), "bar,foo[1-20],foo[1-100]bar,foo[1-101]bar4") self.assertEqual(nodeset[0], "bar") self.assertEqual(nodeset[1], "foo1") self.assertEqual(nodeset[-1], "foo101bar4") def testNodeSetBase(self): """test underlying NodeSetBase class""" rset = RangeSet("1-100,200") self.assertEqual(len(rset), 101) nsb = NodeSetBase("foo%sbar", rset) self.assertEqual(len(nsb), len(rset)) self.assertEqual(str(nsb), "foo[1-100,200]bar") nsbcpy = nsb.copy() self.assertEqual(len(nsbcpy), 101) self.assertEqual(str(nsbcpy), "foo[1-100,200]bar") other = NodeSetBase("foo%sbar", RangeSet("201")) nsbcpy.add(other) self.assertEqual(len(nsb), 101) self.assertEqual(str(nsb), "foo[1-100,200]bar") self.assertEqual(len(nsbcpy), 102) self.assertEqual(str(nsbcpy), "foo[1-100,200-201]bar") def test_nd_simple(self): ns1 = NodeSet("da3c1") ns2 = NodeSet("da3c2") self.assertEqual(str(ns1 | ns2), "da3c[1-2]") ns1 = NodeSet("da3c1-ipmi") ns2 = NodeSet("da3c2-ipmi") self.assertEqual(str(ns1 | ns2), "da3c[1-2]-ipmi") ns1 = NodeSet("da[2-3]c1") ns2 = NodeSet("da[2-3]c2") self.assertEqual(str(ns1 | ns2), "da[2-3]c[1-2]") ns1 = NodeSet("da[2-3]c1") ns2 = NodeSet("da[2-3]c1") self.assertEqual(str(ns1 | ns2), "da[2-3]c1") def test_nd_multiple(self): nodeset = NodeSet("da[30,34-51,59-60]p[1-2]") self.assertEqual(len(nodeset), 42) nodeset = NodeSet("da[30,34-51,59-60]p[1-2],da[70-77]p3") self.assertEqual(len(nodeset), 42+8) self.assertEqual(str(nodeset), "da[30,34-51,59-60]p[1-2],da[70-77]p3") # advanced parsing checks nodeset = NodeSet("da[1-10]c[1-2]") self.assertEqual(len(nodeset), 20) self.assertEqual(str(nodeset), "da[1-10]c[1-2]") nodeset = NodeSet("da[1-10]c[1-2]p") self.assertEqual(len(nodeset), 20) self.assertEqual(str(nodeset), "da[1-10]c[1-2]p") nodeset = NodeSet("da[1-10]c[1-2]p0") self.assertEqual(len(nodeset), 20) self.assertEqual(str(nodeset), "da[1-10]c[1-2]p0") nodeset = NodeSet("da[1-10]c[1-2,8]p0") self.assertEqual(len(nodeset), 30) self.assertEqual(str(nodeset), "da[1-10]c[1-2,8]p0") nodeset = NodeSet("da[1-10]c3p0x3") self.assertEqual(len(nodeset), 10) self.assertEqual(str(nodeset), "da[1-10]c3p0x3") nodeset = NodeSet("[1-7,10]xpc[3,4]p40_3,9xpc[3,4]p40_3,8xpc[3,4]p[40]_[3]") self.assertEqual(len(nodeset), 20) self.assertEqual(str(nodeset), "[1-10]xpc[3-4]p40_3") def test_nd_len(self): ns1 = NodeSet("da3c1") ns2 = NodeSet("da3c2") self.assertEqual(len(ns1 | ns2), 2) ns1 = NodeSet("da[2-3]c1") self.assertEqual(len(ns1), 2) ns2 = NodeSet("da[2-3]c2") self.assertEqual(len(ns2), 2) self.assertEqual(len(ns1) + len(ns2), 4) ns1 = NodeSet("da[1-1000]c[1-2]p[0-1]") self.assertEqual(len(ns1), 4000) ns1 = NodeSet("tronic[0036-1630]c[3-4]") self.assertEqual(len(ns1), 3190) ns1 = NodeSet("tronic[0036-1630]c[3-400]") self.assertEqual(len(ns1), 634810) # checking length of overlapping union ns1 = NodeSet("da[2-3]c[0-1]") self.assertEqual(len(ns1), 4) ns2 = NodeSet("da[2-3]c[1-2]") self.assertEqual(len(ns2), 4) self.assertEqual(len(ns1) + len(ns2), 8) self.assertEqual(len(ns1 | ns2), 6) # da[2-3]c[0-2] # checking length of nD + 1D ns1 = NodeSet("da[2-3]c[0-1]") self.assertEqual(len(ns1), 4) ns2 = NodeSet("node[1-1000]") self.assertEqual(len(ns2), 1000) self.assertEqual(len(ns1) + len(ns2), 1004) self.assertEqual(len(ns1 | ns2), 1004) # checking length of nD + single node ns1 = NodeSet("da[2-3]c[0-1]") self.assertEqual(len(ns1), 4) ns2 = NodeSet("single") self.assertEqual(len(ns2), 1) self.assertEqual(len(ns1) + len(ns2), 5) self.assertEqual(len(ns1 | ns2), 5) def test_nd_iter(self): ns1 = NodeSet("da[2-3]c[0-1]") result = list(iter(ns1)) self.assertEqual(result, ['da2c0', 'da2c1', 'da3c0', 'da3c1']) def test_nd_nsiter(self): ns1 = NodeSet("da[2-3]c[0-1]") result = list(ns1.nsiter()) self.assertEqual(result, [NodeSet('da2c0'), NodeSet('da2c1'), NodeSet('da3c0'), NodeSet('da3c1')]) def test_nd_getitem(self): nodeset = NodeSet("da[30,34-51,59-60]p[1-2]") self.assertEqual(len(nodeset), 42) self.assertEqual(nodeset[0], "da30p1") self.assertEqual(nodeset[1], "da30p2") self.assertEqual(nodeset[2], "da34p1") self.assertEqual(nodeset[-1], "da60p2") nodeset = NodeSet("da[30,34-51,59-60]p[1-2],da[70-77]p2") self.assertEqual(len(nodeset), 42+8) # OLD FOLD #self.assertEqual(str(nodeset), # "da[30,34-51,59-60,70-77]p2,da[30,34-51,59-60]p1") # NEW FOLD self.assertEqual(str(nodeset), "da[30,34-51,59-60]p[1-2],da[70-77]p2") #self.assertEqual(nodeset[0], "da30p2") # OLD FOLD self.assertEqual(nodeset[0], "da30p1") # NEW FOLD def test_nd_split(self): nodeset = NodeSet("foo[1-3]bar[2-4]") self.assertEqual((NodeSet("foo1bar[2-4]"), NodeSet("foo2bar[2-4]"), NodeSet("foo3bar[2-4]")), tuple(nodeset.split(3))) nodeset = NodeSet("foo[1-3]bar[2-4]") self.assertEqual((NodeSet("foo1bar[2-4],foo2bar[2-3]"), NodeSet("foo[2-3]bar4,foo3bar[2-3]")), tuple(nodeset.split(2))) def test_nd_contiguous(self): ns1 = NodeSet("foo[3-100]bar[4-30]") self.assertEqual(str(ns1), "foo[3-100]bar[4-30]") self.assertEqual(len(ns1), 98*27) ns1 = NodeSet("foo[3-100,200]bar4") self.assertEqual(['foo[3-100]bar4', 'foo200bar4'], [str(ns) for ns in ns1.contiguous()]) self.assertEqual(str(ns1), "foo[3-100,200]bar4") ns1 = NodeSet("foo[3-100,102-500]bar[4-30]") self.assertEqual(['foo[3-100]bar[4-30]', 'foo[102-500]bar[4-30]'], [str(ns) for ns in ns1.contiguous()]) self.assertEqual(str(ns1), "foo[3-100,102-500]bar[4-30]") ns1 = NodeSet("foo[3-100,102-500]bar[4-30,37]") self.assertEqual(['foo[3-100]bar[4-30]', 'foo[3-100]bar37', 'foo[102-500]bar[4-30]', 'foo[102-500]bar37'], [str(ns) for ns in ns1.contiguous()]) self.assertEqual(str(ns1), "foo[3-100,102-500]bar[4-30,37]") def test_nd_fold(self): ns = NodeSet("da[2-3]c[1-2],da[3-4]c[3-4]") self.assertEqual(ns, NodeSet("da[2-3]c[1-2],da[3-4]c[3-4]")) self.assertEqual(str(ns), "da3c[1-4],da2c[1-2],da4c[3-4]") ns = NodeSet("da[2-3]c[1-2],da[3-4]c[2-3]") self.assertEqual(ns, NodeSet("da[2-3]c[1-2],da[3-4]c[2-3]")) self.assertEqual(str(ns), "da3c[1-3],da2c[1-2],da4c[2-3]") ns = NodeSet("da[2-3]c[1-2],da[3-4]c[1-2]") self.assertEqual(ns, NodeSet("da[2-3]c[1-2],da[3-4]c[1-2]")) self.assertEqual(str(ns), "da[2-4]c[1-2]") ns = NodeSet("da[2-3]c[1-2]p3,da[3-4]c[1-3]p3") self.assertEqual(ns, NodeSet("da[2-3]c[1-2]p3,da[3-4]c[1-3]p3")) self.assertEqual(str(ns), "da[3-4]c[1-3]p3,da2c[1-2]p3") ns = NodeSet("da[2-3]c[1-2],da[2,5]c[2-3]") self.assertEqual(ns, NodeSet("da[2-3]c[1-2],da[2,5]c[2-3]")) self.assertEqual(str(ns), "da2c[1-3],da3c[1-2],da5c[2-3]") def test_nd_issuperset(self): ns1 = NodeSet("da[2-3]c[1-2]") ns2 = NodeSet("da[1-10]c[1-2]") self.assertTrue(ns2.issuperset(ns1)) self.assertFalse(ns1.issuperset(ns2)) ns1 = NodeSet("da[2-3]c[1-2]") ns1.add("da5c2") self.assertTrue(ns2.issuperset(ns1)) self.assertFalse(ns1.issuperset(ns2)) ns1 = NodeSet("da[2-3]c[1-2]") ns1.add("da5c[1-2]") self.assertTrue(ns2.issuperset(ns1)) self.assertFalse(ns1.issuperset(ns2)) ns1 = NodeSet("da[2-3]c[1-2]") ns1.add("da5c[2-3]") self.assertFalse(ns2.issuperset(ns1)) self.assertFalse(ns1.issuperset(ns2)) # large ranges nodeset = NodeSet("tronic[1-5000]c[1-2]") self.assertEqual(len(nodeset), 10000) self.assertTrue(nodeset.issuperset("tronic[1-5000]c1")) self.assertFalse(nodeset.issuperset("tronic[1-5000]c3")) nodeset = NodeSet("tronic[1-5000]c[1-200]p3") self.assertEqual(len(nodeset), 1000000) self.assertTrue(nodeset.issuperset("tronic[1-5000]c200p3")) self.assertFalse(nodeset.issuperset("tronic[1-5000]c[200-300]p3")) self.assertFalse(nodeset.issuperset("tronic[1-5000/2]c[200-300/2]p3")) def test_nd_issubset(self): nodeset = NodeSet("artcore[3-999]-ib0") self.assertEqual(len(nodeset), 997) self.assertTrue(nodeset.issubset("artcore[3-999]-ib[0-1]")) self.assertTrue(nodeset.issubset("artcore[1-1000]-ib0")) self.assertTrue(nodeset.issubset("artcore[1-1000]-ib[0,2]")) self.assertFalse(nodeset.issubset("artcore[350-427]-ib0")) # check lt self.assertTrue(nodeset < NodeSet("artcore[2-32000]-ib0")) self.assertFalse(nodeset > NodeSet("artcore[2-32000]-ib0")) self.assertTrue(nodeset < NodeSet("artcore[2-32000]-ib0,lounge[35-65/2]")) self.assertFalse(nodeset < NodeSet("artcore[3-999]-ib0")) self.assertFalse(nodeset < NodeSet("artcore[3-980]-ib0")) self.assertFalse(nodeset < NodeSet("artcore[2-998]-ib0")) self.assertTrue(nodeset <= NodeSet("artcore[2-32000]-ib0")) self.assertTrue(nodeset <= NodeSet("artcore[2-32000]-ib0,lounge[35-65/2]")) self.assertTrue(nodeset <= NodeSet("artcore[3-999]-ib0")) self.assertFalse(nodeset <= NodeSet("artcore[3-980]-ib0")) self.assertFalse(nodeset <= NodeSet("artcore[2-998]-ib0")) self.assertEqual(len(nodeset), 997) # check padding issue - fixed in 1.9 self.assertFalse(nodeset.issubset("artcore[0001-1000]-ib0")) # used to be true < 1.9 self.assertFalse(nodeset.issubset("artcore030-ib0")) # multiple patterns case nodeset = NodeSet("tronic[0036-1630],lounge[20-660/2]") self.assertTrue(nodeset < NodeSet("tronic[0036-1630],lounge[20-662/2]")) self.assertTrue(nodeset < NodeSet("tronic[0035-1630],lounge[20-660/2]")) self.assertFalse(nodeset < NodeSet("tronic[0035-1630],lounge[22-660/2]")) self.assertTrue(nodeset < NodeSet("tronic[0036-1630],lounge[20-660/2]," "artcore[034-070]")) self.assertTrue(nodeset < NodeSet("tronic[0032-1880],lounge[2-700/2]," "artcore[039-040]")) self.assertTrue(nodeset.issubset("tronic[0032-1880],lounge[2-700/2],artcore[039-040]")) self.assertTrue(nodeset.issubset(NodeSet("tronic[0032-1880],lounge[2-700/2],artcore[039-040]"))) def test_nd_intersection(self): ns1 = NodeSet("a0b[1-2]") ns2 = NodeSet("a0b1") self.assertEqual(ns1.intersection(ns2), ns2) self.assertEqual(ns1.intersection(ns2), NodeSet("a0b1")) self.assertEqual(len(ns1.intersection(ns2)), 1) ns1 = NodeSet("a0b[1-2]") ns2 = NodeSet("a3b0,a0b1") self.assertEqual(ns1.intersection(ns2), NodeSet("a0b1")) self.assertEqual(len(ns1.intersection(ns2)), 1) ns1 = NodeSet("a[0-100]b[1-2]") ns2 = NodeSet("a[50-150]b[2]") self.assertEqual(ns1.intersection(ns2), NodeSet("a[50-100]b2")) self.assertEqual(len(ns1.intersection(ns2)), 51) def test_nd_nonoverlap(self): ns1 = NodeSet("a[0-2]b[1-3]c[4]") ns1.add("a[0-1]b[2-3]c[4-5]") self.assertEqual(ns1, NodeSet("a[0-1]b[2-3]c[4-5],a[0-2]b1c4,a2b[2-3]c4")) self.assertEqual(ns1, NodeSet("a2b[1-3]c4,a0b[1-2]c4,a0b3c[4-5],a1b[1-2]c4,a1b3c[4-5],a0b2c5,a1b2c5")) self.assertEqual(str(ns1), "a[0-1]b[1-2]c4,a[0-1]b3c[4-5],a2b[1-3]c4,a[0-1]b2c5") self.assertEqual(len(ns1), 13) ns1 = NodeSet("a[0-1]b[2-3]c[4-5]") ns1.add("a[0-2]b[1-3]c[4]") self.assertEqual(ns1, NodeSet("a[0-1]b[2-3]c[4-5],a[0-2]b1c4,a2b[2-3]c4")) self.assertEqual(ns1, NodeSet("a2b[1-3]c4,a0b[1-2]c4,a0b3c[4-5],a1b[1-2]c4,a1b3c[4-5],a0b2c5,a1b2c5")) self.assertEqual(str(ns1), "a[0-1]b[1-2]c4,a[0-1]b3c[4-5],a2b[1-3]c4,a[0-1]b2c5") self.assertEqual(len(ns1), 13) ns1 = NodeSet("a[0-2]b[1-3]c[4],a[0-1]b[2-3]c[4-5]") self.assertEqual(ns1, NodeSet("a[0-2]b[1-3]c[4],a[0-1]b[2-3]c[4-5]")) self.assertEqual(ns1, NodeSet("a2b[1-3]c4,a0b[1-2]c4,a0b3c[4-5],a1b[1-2]c4,a1b3c[4-5],a0b2c5,a1b2c5")) self.assertEqual(ns1, NodeSet("a[0-2]b[1-3]c4,a[0-1]b[2-3]c5")) self.assertEqual(str(ns1), "a[0-1]b[1-2]c4,a[0-1]b3c[4-5],a2b[1-3]c4,a[0-1]b2c5") self.assertEqual(len(ns1), 13) ns1 = NodeSet("a[0-2]b[1-3]c[4-6],a[0-1]b[2-3]c[4-5]") self.assertEqual(ns1, NodeSet("a[0-2]b[1-3]c[4-6],a[0-1]b[2-3]c[4-5]")) self.assertEqual(ns1, NodeSet("a[0-2]b[1-3]c[4-6]")) self.assertEqual(str(ns1), "a[0-2]b[1-3]c[4-6]") self.assertEqual(len(ns1), 3*3*3) ns1 = NodeSet("a[0-2]b[2-3]c[4-6],a[0-1]b[1-3]c[4-5]") self.assertEqual(str(ns1), "a[0-2]b[2-3]c[4-6],a[0-1]b1c[4-5]") self.assertEqual(ns1, NodeSet("a[0-1]b[1-3]c[4-5],a[0-2]b[2-3]c6,a2b[2-3]c[4-5]")) self.assertEqual(ns1, NodeSet("a[0-2]b[2-3]c[4-6],a[0-1]b1c[4-5]")) self.assertEqual(len(ns1), (3*2*3)+(2*1*2)) ns1 = NodeSet("a[0-2]b[2-3]c[4-6],a[0-1]b[1-3]c[4-5]") self.assertEqual(str(ns1), "a[0-2]b[2-3]c[4-6],a[0-1]b1c[4-5]") self.assertEqual(NodeSet("a[0-1]b[1-3]c[4-5],a[0-2]b[2-3]c6,a2b[2-3]c[4-5]"), NodeSet("a[0-2]b[2-3]c[4-6],a[0-1]b1c[4-5]")) self.assertEqual(ns1, NodeSet("a[0-2]b[2-3]c[4-6],a[0-1]b1c[4-5]")) self.assertEqual(ns1, NodeSet("a[0-1]b[1-3]c[4-5],a[0-2]b[2-3]c6,a2b[2-3]c[4-5]")) self.assertEqual(len(ns1), (3*2*3)+(2*1*2)) ns1 = NodeSet("a[0-2]b[2-3]c[4-6],a[0-1]b[1-3]c[4-5],a2b1c[4-6]") self.assertEqual(str(ns1), "a[0-1]b[2-3]c[4-6],a2b[1-3]c[4-6],a[0-1]b1c[4-5]") self.assertEqual(ns1, NodeSet("a[0-1]b[1-3]c[4-5],a[0-2]b[2-3]c6,a2b[2-3]c[4-5],a2b1c[4-6]")) self.assertEqual(ns1, NodeSet("a[0-2]b[2-3]c[4-6],a[0-1]b1c[4-5],a2b1c[4-6]")) self.assertEqual(len(ns1), (3*3*2)+1+(3*2*1)) ns1.add("a1b1c6") self.assertEqual(str(ns1), "a[1-2]b[1-3]c[4-6],a0b[2-3]c[4-6],a0b1c[4-5]") self.assertEqual(ns1, NodeSet("a[0-2]b[2-3]c[4-6],a[0-1]b1c[4-5],a2b1c[4-6],a1b1c6")) self.assertEqual(ns1, NodeSet("a[1-2]b[1-3]c[4-6],a0b[2-3]c[4-6],a0b1c[4-5]")) ns1.add("a0b1c6") self.assertEqual(str(ns1), "a[0-2]b[1-3]c[4-6]") self.assertEqual(ns1, NodeSet("a[0-2]b[1-3]c[4-6]")) self.assertEqual(ns1, NodeSet("a[0-1]b[1-3]c[4-5],a[0-2]b[2-3]c6,a2b[2-3]c[4-5],a2b1c[4-6],a[0-1]b1c6")) self.assertEqual(len(ns1), 3*3*3) def test_nd_difference(self): ns1 = NodeSet("a0b[1-2]") ns2 = NodeSet("a0b1") self.assertEqual(ns1.difference(ns2), NodeSet("a0b2")) self.assertEqual(len(ns1.difference(ns2)), 1) ns1 = NodeSet("a[0-2]b[1-3]c[4-5]") ns2 = NodeSet("a[0-2]b[1-3]c4") self.assertEqual(str(ns1.difference(ns2)), "a[0-2]b[1-3]c5") self.assertEqual(ns1.difference(ns2), NodeSet("a[0-2]b[1-3]c5")) self.assertEqual(len(ns1.difference(ns2)), 9) ns1 = NodeSet("a[0-2]b[1-3]c[4]") ns2 = NodeSet("a[0-3]b[1]c[4-5]") self.assertEqual(ns1.difference(ns2), NodeSet("a[0-2]b[2-3]c4")) self.assertEqual(len(ns1.difference(ns2)), 6) ns1 = NodeSet("a[0-2]b[1-3]c[4],a[0-1]b[2-3]c[4-5]") self.assertEqual(str(ns1), "a[0-1]b[1-2]c4,a[0-1]b3c[4-5],a2b[1-3]c4,a[0-1]b2c5") self.assertEqual(ns1, NodeSet("a[0-2]b[1-3]c[4],a[0-1]b[2-3]c[4-5]")) self.assertEqual(ns1, NodeSet("a[0-1]b[2-3]c[4-5],a[0-2]b1c4,a2b[2-3]c4")) self.assertEqual(ns1, NodeSet("a2b[1-3]c4,a0b[1-2]c4,a0b3c[4-5],a1b[1-2]c4,a1b3c[4-5],a0b2c5,a1b2c5")) self.assertEqual(len(ns1), 3*3 + 2*2) ns2 = NodeSet("a[0-3]b[1]c[4-5]") self.assertEqual(len(ns2), 4*2) self.assertEqual(str(ns1.difference(ns2)), "a[0-1]b[2-3]c[4-5],a2b[2-3]c4") # compare object with different str repr self.assertNotEqual(str(ns1.difference(ns2)), "a[0-2]b[2-3]c4,a[0-1]b[2-3]c5") self.assertEqual(ns1.difference(ns2), NodeSet("a[0-2]b[2-3]c4,a[0-1]b[2-3]c5")) self.assertEqual(len(ns1.difference(ns2)), 3*2+2*2) ns1 = NodeSet("a[0-3]b[1-5]c5") ns2 = NodeSet("a[0-2]b[2-4]c5") self.assertEqual(str(ns1.difference(ns2)), "a[0-2]b[1,5]c5,a3b[1-5]c5") ns1 = NodeSet("a[0-3]b2c5") ns2 = NodeSet("a[0-2]b1c5") self.assertEqual(str(ns1.difference(ns2)), "a[0-3]b2c5") ns1 = NodeSet("a[0-3]b[1-4]c[5]") ns2 = NodeSet("a[0-2]b1c5") self.assertEqual(str(ns1.difference(ns2)), "a[0-2]b[2-4]c5,a3b[1-4]c5") ns1 = NodeSet("a[0-2]b[1-4]c5") ns2 = NodeSet("a[0-3]b[2-3]c5") self.assertEqual(str(ns1.difference(ns2)), "a[0-2]b[1,4]c5") ns1 = NodeSet("a[0-2]b1c5") ns2 = NodeSet("a[0-3]b[1-4]c[5]") self.assertEqual(str(ns1.difference(ns2)), "") ns1 = NodeSet("a[1-4]b1c5") ns2 = NodeSet("a[0-3]b1c5") self.assertEqual(str(ns1.difference(ns2)), "a4b1c5") ns1 = NodeSet("a[0-2]b1c[5-6]") ns2 = NodeSet("a[0-3]b[1-4]c[5]") self.assertEqual(str(ns1.difference(ns2)), "a[0-2]b1c6") ns1 = NodeSet("a[0-2]b[1-3]c[5]") ns2 = NodeSet("a[0-3]b[1-4]c[5]") self.assertEqual(ns1.difference(ns2), NodeSet()) self.assertEqual(len(ns1.difference(ns2)), 0) def test_nd_difference_test(self): #ns1 = NodeSet("a2b4") #ns2 = NodeSet("a2b6") #nsdiff = ns1.difference(ns2) #self.assertEqual(str(nsdiff), "a2b4") #self.assertEqual(nsdiff, NodeSet("a2b4")) ns1 = NodeSet("a[1-10]b[1-10]") ns2 = NodeSet("a[5-20]b[5-20]") nsdiff = ns1.difference(ns2) self.assertEqual(str(nsdiff), "a[1-4]b[1-10],a[5-10]b[1-4]") self.assertEqual(nsdiff, NodeSet("a[1-4]b[1-10],a[1-10]b[1-4]")) # manually checked with overlap # node[1-100]x[1-10] -x node4x4 def test_nd_difference_m(self): ns1 = NodeSet("a[2-3,5]b[1,4],a6b5") ns2 = NodeSet("a5b4,a6b5") nsdiff = ns1.difference(ns2) self.assertEqual(str(nsdiff), "a[2-3]b[1,4],a5b1") self.assertEqual(nsdiff, NodeSet("a[2-3]b[1,4],a5b1")) self.assertEqual(nsdiff, NodeSet("a[2-3,5]b1,a[2-3]b4")) # same with difference_update: ns1 = NodeSet("a[2-3,5]b[1,4],a6b5") ns2 = NodeSet("a5b4,a6b5") ns1.difference_update(ns2) self.assertEqual(str(ns1), "a[2-3]b[1,4],a5b1") self.assertEqual(ns1, NodeSet("a[2-3]b[1,4],a5b1")) self.assertEqual(ns1, NodeSet("a[2-3,5]b1,a[2-3]b4")) ns1 = NodeSet("a[2-3,5]b[1,4]p1,a6b5p1") ns2 = NodeSet("a5b4p1,a6b5p1") nsdiff = ns1.difference(ns2) self.assertEqual(str(nsdiff), "a[2-3]b[1,4]p1,a5b1p1") self.assertEqual(nsdiff, NodeSet("a[2-3]b[1,4]p1,a5b1p1")) self.assertEqual(nsdiff, NodeSet("a[2-3,5]b1p1,a[2-3]b4p1")) # manually checked ns1 = NodeSet("a[2-3]b[0,3-4],a[6-10]b[0-2]") ns2 = NodeSet("a[3-6]b[2-3]") nsdiff = ns1.difference(ns2) self.assertEqual(str(nsdiff), "a[7-10]b[0-2],a2b[0,3-4],a3b[0,4],a6b[0-1]") self.assertEqual(nsdiff, NodeSet("a[7-10]b[0-2],a[2-3]b[0,4],a6b[0-1],a2b3")) self.assertEqual(nsdiff, NodeSet("a[2-3,6-10]b0,a[6-10]b1,a[7-10]b2,a2b3,a[2-3]b4")) # manually checked ns1 = NodeSet("a[2-3,5]b4c[1,4],a6b4c5") ns2 = NodeSet("a5b4c4,a6b4c5") nsdiff = ns1.difference(ns2) self.assertEqual(str(nsdiff), "a[2-3]b4c[1,4],a5b4c1") self.assertEqual(nsdiff, NodeSet("a[2-3]b4c[1,4],a5b4c1")) self.assertEqual(nsdiff, NodeSet("a[2-3,5]b4c1,a[2-3]b4c4")) ns1 = NodeSet("a[1-6]b4") ns2 = NodeSet("a5b[2-5]") nsdiff = ns1.difference(ns2) self.assertEqual(str(nsdiff), "a[1-4,6]b4") self.assertEqual(nsdiff, NodeSet("a[1-4,6]b4")) def test_nd_xor(self): nodeset = NodeSet("artcore[3-999]p1") self.assertEqual(len(nodeset), 997) nodeset.symmetric_difference_update("artcore[1-2000]p1") self.assertEqual(str(nodeset), "artcore[1-2,1000-2000]p1") self.assertEqual(len(nodeset), 1003) nodeset = NodeSet("artcore[3-999]p1,lounge") self.assertEqual(len(nodeset), 998) nodeset.symmetric_difference_update("artcore[1-2000]p1") self.assertEqual(len(nodeset), 1004) self.assertEqual(str(nodeset), "artcore[1-2,1000-2000]p1,lounge") nodeset = NodeSet("artcore[3-999]p1,lounge") self.assertEqual(len(nodeset), 998) nodeset.symmetric_difference_update("artcore[1-2000]p1,lounge") self.assertEqual(len(nodeset), 1003) self.assertEqual(str(nodeset), "artcore[1-2,1000-2000]p1") nodeset = NodeSet("artcore[3-999]p1,lounge") self.assertEqual(len(nodeset), 998) nodeset2 = NodeSet("artcore[1-2000]p1,lounge") nodeset.symmetric_difference_update(nodeset2) self.assertEqual(len(nodeset), 1003) self.assertEqual(str(nodeset), "artcore[1-2,1000-2000]p1") self.assertEqual(len(nodeset2), 2001) # check const argument nodeset.symmetric_difference_update("artcore[1-2000]p1,lounge") self.assertEqual(len(nodeset), 998) self.assertEqual(str(nodeset), "artcore[3-999]p1,lounge") # first = NodeSet("a[2-3,5]b[1,4],a6b5") second = NodeSet("a[4-6]b[3-6]") first.symmetric_difference_update(second) self.assertEqual(str(first), "a[2-3]b[1,4],a4b[3-6],a5b[1,3,5-6],a6b[3-4,6]") self.assertEqual(first, NodeSet("a[2-3]b[1,4],a4b[3-6],a5b[1,3,5-6],a6b[3-4,6]")) self.assertEqual(first, NodeSet("a[4-6]b[3,6],a[2-3]b[1,4],a4b[4-5],a5b[1,5],a6b4")) first = NodeSet("a[1-50]b[1-20]") second = NodeSet("a[40-60]b[10-30]") first.symmetric_difference_update(second) self.assertEqual(str(first), "a[1-39]b[1-20],a[51-60]b[10-30],a[40-50]b[1-9,21-30]") self.assertEqual(first, NodeSet("a[1-39]b[1-20],a[40-60]b[21-30],a[51-60]b[10-20],a[40-50]b[1-9]")) first = NodeSet("a[1-2]p[1-2]") second = NodeSet("a[2-3]p[2-3]") first.symmetric_difference_update(second) self.assertEqual(str(first), "a1p[1-2],a2p[1,3],a3p[2-3]") self.assertEqual(first, NodeSet("a1p1,a1p2,a2p1,a2p3,a3p2,a3p3")) first = NodeSet("a[3-29]p[1-9,50-58]") second = NodeSet("a[1-110]p[4-56]") first.symmetric_difference_update(second) self.assertEqual(str(first), "a[1-2,30-110]p[4-56],a[3-29]p[1-3,10-49,57-58]") self.assertEqual(first, NodeSet("a[1-2,30-110]p[4-56],a[3-29]p[1-3,10-49,57-58]")) ns1 = NodeSet("a[1-6]b4") ns2 = NodeSet("a5b[2-5]") ns1.symmetric_difference_update(ns2) self.assertEqual(str(ns1), "a[1-4,6]b4,a5b[2-3,5]") self.assertEqual(ns1, NodeSet("a[1-4]b4,a5b[2-3,5],a6b4")) self.assertEqual(ns1, NodeSet("a[1-4,6]b4,a5b[2-3,5]")) def test_autostep(self): """test NodeSet autostep (1D)""" n1 = NodeSet("n1,n3,n5") # autostep arg does override origin autostep n2 = NodeSet(n1, autostep=3) self.assertEqual(str(n2), "n[1-5/2]") n2.update("p2,p5,p8") self.assertEqual(str(n2), "n[1-5/2],p[2-8/3]") n3 = NodeSet(n2, autostep=AUTOSTEP_DISABLED) self.assertEqual(str(n2), "n[1-5/2],p[2-8/3]") self.assertEqual(str(n3), "n[1,3,5],p[2,5,8]") # test xor, the other operation that can add nodes n4 = NodeSet() n4.symmetric_difference_update(n2) self.assertEqual(str(n2), "n[1-5/2],p[2-8/3]") self.assertEqual(str(n4), "n[1-5/2],p[2-8/3]") n5 = NodeSet(autostep=AUTOSTEP_DISABLED) n5.symmetric_difference_update(n2) self.assertEqual(str(n2), "n[1-5/2],p[2-8/3]") self.assertEqual(str(n5), "n[1,3,5],p[2,5,8]") n4 = NodeSet() n4b = n4.symmetric_difference(n2) self.assertEqual(str(n2), "n[1-5/2],p[2-8/3]") self.assertEqual(str(n4), "") self.assertEqual(str(n4b), "n[1-5/2],p[2-8/3]") n5 = NodeSet(autostep=AUTOSTEP_DISABLED) n5b = n5.symmetric_difference(n2) self.assertEqual(str(n2), "n[1-5/2],p[2-8/3]") self.assertEqual(str(n5), "") self.assertEqual(str(n5b), "n[1,3,5],p[2,5,8]") def test_autostep_property(self): """test NodeSet autostep property (1D)""" n1 = NodeSet("n1,n3,n5,p04,p07,p10,p13") self.assertEqual(str(n1), "n[1,3,5],p[04,07,10,13]") self.assertEqual(len(n1), 7) self.assertEqual(n1.autostep, None) n1.autostep = 2 self.assertEqual(str(n1), "n[1-5/2],p[04-13/3]") self.assertEqual(n1.autostep, 2) self.assertEqual(len(n1), 7) n1.autostep = 5 self.assertEqual(str(n1), "n[1,3,5],p[04,07,10,13]") n1.autostep = 4 self.assertEqual(str(n1), "n[1,3,5],p[04-13/3]") n1.autostep = 3 self.assertEqual(str(n1), "n[1-5/2],p[04-13/3]") self.assertEqual(len(n1), 7) n1.autostep = None self.assertEqual(str(n1), "n[1,3,5],p[04,07,10,13]") self.assertEqual(n1.autostep, None) self.assertEqual(len(n1), 7) # check change + init/copy n1.autostep = 4 n2 = NodeSet(n1) self.assertEqual(n1.autostep, 4) # autostep set as 'inherit' self.assertEqual(n2.autostep, None) # check that self.assertEqual(str(n2), "n[1,3,5],p[04-13/3]") n2.autostep = 2 self.assertEqual(str(n2), "n[1-5/2],p[04-13/3]") self.assertEqual(n1.autostep, 4) # no change self.assertEqual(n2.autostep, 2) n1.autostep = 4 n2 = NodeSet(n1, autostep=2) self.assertEqual(n1.autostep, 4) self.assertEqual(n2.autostep, 2) self.assertEqual(str(n2), "n[1-5/2],p[04-13/3]") n1.autostep = 4 n2 = NodeSet(n1, autostep=AUTOSTEP_DISABLED) self.assertEqual(n1.autostep, 4) self.assertEqual(n2.autostep, AUTOSTEP_DISABLED) self.assertEqual(str(n2), "n[1,3,5],p[04,07,10,13]") n1.autostep = 3 self.assertEqual(n1.copy().autostep, 3) n1 = NodeSet("n09,n11") self.assertEqual(str(n1), "n[09,11]") self.assertEqual(len(n1), 2) self.assertEqual(n1.autostep, None) n1.autostep = 2 self.assertEqual(str(n1), "n[09-11/2]") n1.autostep = 3 self.assertEqual(str(n1), "n[09,11]") n1 = NodeSet("n1,n3,n5,p03,p06,p09,p012,p015") self.assertEqual(str(n1), "n[1,3,5],p[03,06,09,012,015]") self.assertEqual(len(n1), 8) self.assertEqual(n1.autostep, None) n1.autostep = 2 self.assertEqual(str(n1), "n[1-5/2],p[03-09/3,012-015/3]") n1.autostep = 3 self.assertEqual(str(n1), "n[1-5/2],p[03-09/3,012,015]") n1 = NodeSet("n1,n3,n5,p03,p06,p09") self.assertEqual(str(n1), "n[1,3,5],p[03,06,09]") self.assertEqual(len(n1), 6) self.assertEqual(n1.autostep, None) n1.autostep = 2 self.assertEqual(str(n1), "n[1-5/2],p[03-09/3]") self.assertEqual(n1.autostep, 2) n1 = NodeSet("n1,n03,n05") self.assertEqual(str(n1), "n[1,03,05]") self.assertEqual(len(n1), 3) self.assertEqual(n1.autostep, None) n1.autostep = 3 self.assertEqual(str(n1), "n[1,03,05]") n1 = NodeSet("n1,n03,n05,n07") self.assertEqual(str(n1), "n[1,03,05,07]") self.assertEqual(len(n1), 4) self.assertEqual(n1.autostep, None) n1.autostep = 2 self.assertEqual(str(n1), "n[1,03-07/2]") def test_nd_autostep(self): """test NodeSet autostep (nD)""" n1 = NodeSet("p2n1,p2n3,p2n5") # autostep arg does override origin autostep n2 = NodeSet(n1, autostep=3) self.assertEqual(str(n1), "p2n[1,3,5]") # no change! self.assertEqual(str(n2), "p2n[1-5/2]") # test multi-pattern nD n2.update("p2p2,p2p4,p2p6") self.assertEqual(str(n1), "p2n[1,3,5]") # no change! self.assertEqual(str(n2), "p2n[1-5/2],p2p[2-6/2]") n3 = NodeSet("p2x1,p2x4,p2x7") n2.update(n3) self.assertEqual(str(n3), "p2x[1,4,7]") # no change! self.assertEqual(str(n2), "p2n[1-5/2],p2p[2-6/2],p2x[1-7/3]") # add nodes to same pattern (but not the first one) n4 = NodeSet("p2p8,p2p14,p2p20") n2.update(n4) self.assertEqual(str(n4), "p2p[8,14,20]") # no change! self.assertEqual(str(n2), "p2n[1-5/2],p2p[2-8/2,14,20],p2x[1-7/3]") n4 = NodeSet(n2, autostep=AUTOSTEP_DISABLED) # no change on n2... self.assertEqual(str(n2), "p2n[1-5/2],p2p[2-8/2,14,20],p2x[1-7/3]") # explicitly disabled on n4 n4_noautostep_str = "p2n[1,3,5],p2p[2,4,6,8,14,20],p2x[1,4,7]" self.assertEqual(str(n4), n4_noautostep_str) # test xor, the other operation that can add nodes n5 = NodeSet() n5.symmetric_difference_update(n2) self.assertEqual(str(n5), "p2n[1-5/2],p2p[2-8/2,14,20],p2x[1-7/3]") n6 = NodeSet(autostep=AUTOSTEP_DISABLED) n6.symmetric_difference_update(n2) self.assertEqual(str(n6), n4_noautostep_str) n5 = NodeSet() n5b = n5.symmetric_difference(n2) # no change on n2... self.assertEqual(str(n2), "p2n[1-5/2],p2p[2-8/2,14,20],p2x[1-7/3]") self.assertEqual(str(n5), "") self.assertEqual(str(n5b), "p2n[1-5/2],p2p[2-8/2,14,20],p2x[1-7/3]") n6 = NodeSet(autostep=AUTOSTEP_DISABLED) n6b = n6.symmetric_difference(n2) # no change on n2... self.assertEqual(str(n2), "p2n[1-5/2],p2p[2-8/2,14,20],p2x[1-7/3]") self.assertEqual(str(n6), "") self.assertEqual(str(n6b), n4_noautostep_str) def test_nd_autostep_property(self): """test NodeSet autostep property (nD)""" n1 = NodeSet("p1n4,p2x011,p1n6,p2x015,p1n2,p2x019,p1n0,p2x003") self.assertEqual(str(n1), "p1n[0,2,4,6],p2x[003,011,015,019]") self.assertEqual(len(n1), 8) self.assertEqual(n1.autostep, None) n1.autostep = 2 # 2 is really a too small value for autostep, but well... self.assertEqual(str(n1), "p1n[0-6/2],p2x[003-011/8,015-019/4]") self.assertEqual(n1.autostep, 2) self.assertEqual(len(n1), 8) n1.autostep = 5 self.assertEqual(str(n1), "p1n[0,2,4,6],p2x[003,011,015,019]") n1.autostep = 4 self.assertEqual(str(n1), "p1n[0-6/2],p2x[003,011,015,019]") n1.autostep = 3 self.assertEqual(str(n1), "p1n[0-6/2],p2x[003,011-019/4]") self.assertEqual(len(n1), 8) n1.autostep = None self.assertEqual(str(n1), "p1n[0,2,4,6],p2x[003,011,015,019]") self.assertEqual(n1.autostep, None) self.assertEqual(len(n1), 8) # check change + init/copy n1.autostep = 4 n2 = NodeSet(n1) self.assertEqual(n1.autostep, 4) # autostep set as 'inherit' self.assertEqual(n2.autostep, None) # check that self.assertEqual(str(n2), "p1n[0-6/2],p2x[003,011,015,019]") n2.autostep = 2 self.assertEqual(str(n2), "p1n[0-6/2],p2x[003-011/8,015-019/4]") self.assertEqual(n1.autostep, 4) # no change self.assertEqual(n2.autostep, 2) n1.autostep = 4 n2 = NodeSet(n1, autostep=2) self.assertEqual(n1.autostep, 4) self.assertEqual(n2.autostep, 2) self.assertEqual(str(n2), "p1n[0-6/2],p2x[003-011/8,015-019/4]") n1.autostep = 4 n2 = NodeSet(n1, autostep=AUTOSTEP_DISABLED) self.assertEqual(n1.autostep, 4) self.assertEqual(n2.autostep, AUTOSTEP_DISABLED) self.assertEqual(str(n2), "p1n[0,2,4,6],p2x[003,011,015,019]") n1.autostep = 3 self.assertEqual(n1.copy().autostep, 3) def test_nd_fold_axis(self): """test NodeSet fold_axis feature""" n1 = NodeSet("a3b2c0,a2b3c1,a2b4c1,a1b2c0,a1b2c1,a3b2c1,a2b5c1") # default dim is unlimited self.assertEqual(str(n1), "a[1,3]b2c[0-1],a2b[3-5]c1") self.assertEqual(len(n1), 7) # fold along three axis n1.fold_axis = (0, 1, 2) self.assertEqual(str(n1), "a[1,3]b2c[0-1],a2b[3-5]c1") self.assertEqual(len(n1), 7) # fold along one axis n1.fold_axis = [0] self.assertEqual(str(n1), "a[1,3]b2c0,a[1,3]b2c1,a2b3c1,a2b4c1,a2b5c1") self.assertEqual(len(n1), 7) n1.fold_axis = [1] self.assertEqual(str(n1), "a1b2c0,a3b2c0,a1b2c1,a3b2c1,a2b[3-5]c1") self.assertEqual(len(n1), 7) n1.fold_axis = [2] self.assertEqual(str(n1), "a1b2c[0-1],a3b2c[0-1],a2b3c1,a2b4c1,a2b5c1") self.assertEqual(len(n1), 7) # reverse n1.fold_axis = [-1] self.assertEqual(str(n1), "a1b2c[0-1],a3b2c[0-1],a2b3c1,a2b4c1,a2b5c1") self.assertEqual(len(n1), 7) n1.fold_axis = [-2] self.assertEqual(str(n1), "a1b2c0,a3b2c0,a1b2c1,a3b2c1,a2b[3-5]c1") self.assertEqual(len(n1), 7) n1.fold_axis = [-3] self.assertEqual(str(n1), "a[1,3]b2c0,a[1,3]b2c1,a2b3c1,a2b4c1,a2b5c1") self.assertEqual(len(n1), 7) # out of bound silently re-expand everything n1.fold_axis = [3] self.assertEqual(str(n1), "a1b2c0,a3b2c0,a1b2c1,a3b2c1,a2b3c1,a2b4c1,a2b5c1") n1.fold_axis = [-4] self.assertEqual(str(n1), "a1b2c0,a3b2c0,a1b2c1,a3b2c1,a2b3c1,a2b4c1,a2b5c1") # fold along two axis n1.fold_axis = [0, 1] self.assertEqual(str(n1), "a[1,3]b2c0,a[1,3]b2c1,a2b[3-5]c1") self.assertEqual(len(n1), 7) n1.fold_axis = [0, 2] self.assertEqual(str(n1), "a[1,3]b2c[0-1],a2b3c1,a2b4c1,a2b5c1") self.assertEqual(len(n1), 7) n1.fold_axis = [1, 2] self.assertEqual(str(n1), "a1b2c[0-1],a3b2c[0-1],a2b[3-5]c1") self.assertEqual(len(n1), 7) # reset fold_axis n1.fold_axis = None self.assertEqual(str(n1), "a[1,3]b2c[0-1],a2b[3-5]c1") self.assertEqual(len(n1), 7) # fold_axis: constructor and copy n1.fold_axis = (0, 2) n2 = NodeSet(n1) self.assertEqual(n1.fold_axis, (0, 2)) self.assertTrue(n2.fold_axis is None) n2 = NodeSet(n1, fold_axis=n1.fold_axis) self.assertEqual(n1.fold_axis, (0, 2)) self.assertEqual(n2.fold_axis, (0, 2)) self.assertEqual(str(n2), "a[1,3]b2c[0-1],a2b3c1,a2b4c1,a2b5c1") # fold_axis is kept when using copy() n2 = n1.copy() self.assertEqual(n1.fold_axis, (0, 2)) self.assertEqual(n2.fold_axis, (0, 2)) self.assertEqual(str(n2), "a[1,3]b2c[0-1],a2b3c1,a2b4c1,a2b5c1") def test_nd_fold_axis_multi(self): """test NodeSet fold_axis feature (ultimate)""" # A single variable-nD nodeset n1 = NodeSet("master,slave,ln0,ln1,da1c1,da1c2,da2c1,da2c2," "x1y1z1,x1y1z2,x1y2z1,x1y2z2," "x2y1z1,x2y1z2,x2y2z1,x2y2z2") # default is unlimited self.assertEqual(str(n1), "da[1-2]c[1-2],ln[0-1],master,slave,x[1-2]y[1-2]z[1-2]") self.assertEqual(len(n1), 16) # fold along one axis n1.fold_axis = [0] self.assertEqual(str(n1), "da[1-2]c1,da[1-2]c2,ln[0-1],master,slave,x[1-2]y1z1,x[1-2]y2z1,x[1-2]y1z2,x[1-2]y2z2") self.assertEqual(len(n1), 16) n1.fold_axis = [1] self.assertEqual(str(n1), "da1c[1-2],da2c[1-2],ln0,ln1,master,slave,x1y[1-2]z1,x2y[1-2]z1,x1y[1-2]z2,x2y[1-2]z2") self.assertEqual(len(n1), 16) n1.fold_axis = [2] self.assertEqual(str(n1), "da1c1,da2c1,da1c2,da2c2,ln0,ln1,master,slave,x1y1z[1-2],x2y1z[1-2],x1y2z[1-2],x2y2z[1-2]") self.assertEqual(len(n1), 16) # reverse n1.fold_axis = [-1] # first indices from the end self.assertEqual(str(n1), "da1c[1-2],da2c[1-2],ln[0-1],master,slave,x1y1z[1-2],x2y1z[1-2],x1y2z[1-2],x2y2z[1-2]") self.assertEqual(len(n1), 16) n1.fold_axis = [-2] # second indices from the end self.assertEqual(str(n1), "da[1-2]c1,da[1-2]c2,ln0,ln1,master,slave,x1y[1-2]z1,x2y[1-2]z1,x1y[1-2]z2,x2y[1-2]z2") self.assertEqual(len(n1), 16) n1.fold_axis = [-3] # etc. self.assertEqual(str(n1), "da1c1,da2c1,da1c2,da2c2,ln0,ln1,master,slave,x[1-2]y1z1,x[1-2]y2z1,x[1-2]y1z2,x[1-2]y2z2") self.assertEqual(len(n1), 16) # out of bound silently re-expand everything n1.fold_axis = [3] self.assertEqual(str(n1), "da1c1,da2c1,da1c2,da2c2,ln0,ln1,master,slave,x1y1z1,x2y1z1,x1y2z1,x2y2z1,x1y1z2,x2y1z2,x1y2z2,x2y2z2") n1.fold_axis = [-4] self.assertEqual(str(n1), "da1c1,da2c1,da1c2,da2c2,ln0,ln1,master,slave,x1y1z1,x2y1z1,x1y2z1,x2y2z1,x1y1z2,x2y1z2,x1y2z2,x2y2z2") # fold along two axis n1.fold_axis = [0, 1] self.assertEqual(str(n1), "da[1-2]c[1-2],ln[0-1],master,slave,x[1-2]y[1-2]z1,x[1-2]y[1-2]z2") self.assertEqual(len(n1), 16) n1.fold_axis = [0, 2] self.assertEqual(str(n1), "da[1-2]c1,da[1-2]c2,ln[0-1],master,slave,x[1-2]y1z[1-2],x[1-2]y2z[1-2]") self.assertEqual(len(n1), 16) n1.fold_axis = [1, 2] self.assertEqual(str(n1), "da1c[1-2],da2c[1-2],ln0,ln1,master,slave,x1y[1-2]z[1-2],x2y[1-2]z[1-2]") self.assertEqual(len(n1), 16) # fold along three axis n1.fold_axis = range(3) self.assertEqual(str(n1), "da[1-2]c[1-2],ln[0-1],master,slave,x[1-2]y[1-2]z[1-2]") self.assertEqual(len(n1), 16) def test_unicode(self): """test NodeSet with unicode string""" nodeset = NodeSet(u"node1") self._assertNode(nodeset, "node1") if sys.version_info < (3, 0, 0): # unicode cannot work in Python 2 as we use str() internally self.assertRaises(UnicodeEncodeError, NodeSet, u"\u0ad0[000-042]") else: # unicode is supported in Python 3 self.assertEqual(str(NodeSet(u"\u0ad0[000-042]")), u"\u0ad0[000-042]") self.assertEqual(str(NodeSet(u"\u0ad0[000-042]")), "ૐ[000-042]") def test_nd_fold_padding(self): """test NodeSet nD heuristic folding with padding""" # Ticket #286 - not broken in 1.7 n1 = NodeSet("n1c01,n1c02,n1c03,n1c04,n1c05,n1c06,n1c07,n1c08,n1c09,n2c01,n2c02,n2c03,n2c04,n2c05,n2c06,n2c07,n2c08,n2c09,n3c01,n3c02,n3c03,n3c04,n3c05,n3c06,n3c07,n3c08,n3c09,n4c01,n4c02,n4c03,n4c04,n4c05,n4c06,n4c07") self.assertEqual(str(n1), "n[1-3]c[01-09],n4c[01-07]") self.assertEqual(len(n1), 34) # Ticket #286 - broken in 1.7 - trigger RangeSetND._fold_multivariate_expand full expand n1 = NodeSet("n1c01,n1c02,n1c03,n1c04,n1c05,n1c06,n1c07,n1c08,n1c09,n2c01,n2c02,n2c03,n2c04,n2c05,n2c06,n2c07,n2c08,n2c09,n3c01,n3c02,n3c03,n3c04,n3c05,n3c06,n3c07,n3c08,n3c09,n4c01,n4c02,n4c03,n4c04,n4c05,n4c06,n4c07,n4c08,n4c09") self.assertEqual(str(n1), "n[1-4]c[01-09]") self.assertEqual(len(n1), 36) def test_fully_numeric(self): # supported from 1.8 (#338) n1 = NodeSet("3,5,[7-10,40]") self.assertEqual(str(n1), "[3,5,7-10,40]") self.assertEqual(len(n1), 7) n1 = NodeSet("nova3,nova4,5,nova6") self.assertEqual(str(n1), "5,nova[3-4,6]") self.assertEqual(len(n1), 4) n1 = NodeSet("nova3,nova4,[5-8],nova6") self.assertEqual(str(n1), "[5-8],nova[3-4,6]") self.assertEqual(len(n1), 7) n1 = NodeSet("[0-10]") self.assertEqual(str(n1), "[0-10]") self.assertEqual(len(n1), 11) self.assertEqual(len(n1), 11) # leading 0 along with mixed lengths padding self._assertEqual("[07-09,010]") self._assertNS("0[7-10]", NodeSetParseRangeError) self._assertNS("0[7-9,10]", NodeSetParseRangeError) # expanded to 7-10 first self._assertEqual("0[7-9,010]", "[07-09,0010]") self._assertEqual("0[07-09,10]", "[007-010]") self._assertEqual("0[07-09,010]", "[007-009,0010]") self._assertNS("0[0-10]", NodeSetParseRangeError) # trailing 0 along with mixed lengths padding self._assertNS("[0-10]0", NodeSetParseRangeError) self._assertNS("0[0-10]0", NodeSetParseRangeError) def test_negative_ranges(self): # supported from 1.9.1 (#515) n1 = NodeSet("n[-5]") self.assertEqual(str(n1), "n-5") self.assertEqual(len(n1), 1) n1 = NodeSet("n[-1-0]") self.assertEqual(str(n1), "n[-1-0]") self.assertEqual(len(n1), 2) n1 = NodeSet("n[-5-5]") self.assertEqual(str(n1), "n[-5-5]") self.assertEqual(len(n1), 2*5+1) n1 = NodeSet("n[-12-12]") self.assertEqual(str(n1), "n[-12-12]") self.assertEqual(len(n1), 12*2+1) n1 = NodeSet("n[-12,-10--9,-5--1,1-5]") self.assertEqual(str(n1), "n[-12,-10--9,-5--1,1-5]") self.assertEqual(len(n1), 13) n1 = NodeSet("n[1-5,-12,-5--1,-10--9]") self.assertEqual(str(n1), "n[-12,-10--9,-5--1,1-5]") self.assertEqual(len(n1), 13) n1 = NodeSet("n[1,-10,2-4,-12,5,-5,-4,-3,-9,-2--1]") self.assertEqual(str(n1), "n[-12,-10--9,-5--1,1-5]") self.assertEqual(len(n1), 13) n1 = NodeSet("n[1,-10,2-4,-12],n[5,-5,-4,-3,-9,-2--1]") self.assertEqual(str(n1), "n[-12,-10--9,-5--1,1-5]") self.assertEqual(len(n1), 13) # padding in negative range is not supported self._assertNS("n[-001]", NodeSetParseRangeError)