def write_files(self):
     the_file_xdict = XDict(self.file_dictionary)
     for filepath, file_string in the_file_xdict.xitems():
         fw = nfile.FileWriter(filepath)
         try:
             fw.write_utf8(file_string)
         except TypeError as te: # catch unicode write errors
             fw.write(file_string)

 def test_xdict_key_xlist(self):
     xd = XDict({'a_one': 'value_one', 'b_two': 'value_two', 'c_three': 'value_three'}, {'attrkey': 'attrval'})
     xl = xd.key_xlist()
     self.assertEqual(type(xl), type(XList(['item']))) #actually makes XList
     self.assertTrue(len(xl) == 3) # includes all items
     self.assertTrue('a_one' in xl) # includes appropriate items in XList
     self.assertTrue('b_two' in xl)
     self.assertTrue('c_three' in xl)
     self.assertEqual(xl.attrkey, 'attrval') # includes original attributes

 def test_xdict_equals_newobj_addattr(self):
     xd = XDict({'key': 'value'})
     xn = XDict({'key': 'value'})
     xd.test = 'testing'
     xn.test = 'testing'
     self.assertTrue(hasattr(xd, 'test'))
     self.assertTrue(hasattr(xn, 'test'))
     self.assertTrue(xd.equals(xn))
     self.assertTrue(xd == xn)
     self.assertFalse(xd != xn)

        def test_xdict_map_to_vals(self):
            def cap_val(xdict_val):
                return xdict_val.upper()

            xd = XDict({'a_one': 'value_one', 'b_two': 'value_two', 'a_three': 'value_three'}, {'attrkey': 'attrval'})
            xd = xd.map_to_vals(cap_val)
            self.assertEqual(type(xd), type(XDict({'test': 'dict'})))
            self.assertTrue(len(xd.values()) == 3)
            self.assertTrue('VALUE_ONE' in xd.values())
            self.assertTrue('VALUE_TWO' in xd.values())
            self.assertTrue('VALUE_THREE' in xd.values())
            self.assertEqual(xd.attrkey, 'attrval')

        def test_xdict_conditional_map_to_vals(self):
            def true_a(xdict_key):
                return xdict_key.startswith('a')

            def cap_val(xdict_val):
                return xdict_val.upper()

            xd = XDict({'a_one': 'value_one', 'b_two': 'value_two', 'a_three': 'value_three'}, {'attrkey': 'attrval'})
            xd = xd.conditional_map_to_vals(true_a, cap_val)
            self.assertTrue(len(xd.values()) == 3)
            self.assertTrue('VALUE_ONE' in xd.values())
            self.assertTrue('VALUE_THREE' in xd.values())
            self.assertTrue('value_two' in xd.values())
            self.assertFalse('VALUE_TWO' in xd.values()) # the b_two value was not converted as per the conditional function

 def test_xdict_val_count_integer(self):
     xd = XDict({'one': 1, 'two': 1, 'three': 3})
     self.assertEqual(xd.val_count(1), 2)
     self.assertEqual(xd.val_count(3), 1)
     self.assertEqual(xd.val_count(10), 0) # missing value count is 0

 def test_xdict_val_count_string(self):
     xd = XDict({'one': '1', 'two': '1', 'three': '3'})
     self.assertEqual(xd.val_count('1'), 2)
     self.assertEqual(xd.val_count('3'), 1)
     self.assertEqual(xd.val_count('10'), 0) # missing value count is 0

 def test_xdict_sum_vals_string_type(self):
     xd = XDict({'one': '1', 'two': '2', 'three': '3'})
     with self.assertRaises(TypeError): # raises TypeError when inappropriate types in the XDict vals
         xd.sum_vals()

 def test_xdict_equals_newobj_emptyattrs(self):
     xd = XDict({'key': 'value'})
     xn = XDict({'key': 'value'})
     self.assertTrue(xd.equals(xn))
     self.assertTrue(xd == xn)
     self.assertFalse(xd != xn)

 def test_xdict_equals_newobj_diffattrval(self):
     xd = XDict({'key': 'value'}, {'attrkey': 'diff'})
     xn = XDict({'key': 'value'}, {'attrkey': 'attrval'})
     self.assertFalse(xd.equals(xn))
     self.assertFalse(xd == xn)
     self.assertTrue(xd != xn)

 def test_xdict_key_intersection_when_none_present(self):
     xd = XDict({'one': 1, 'two': 1, 'three': 3})
     xn = XDict({'oneone': 1, 'twotwo': 1, 'threethree': 3})
     self.assertEqual(len(xd.intersection(xn)), 0)
     self.assertEqual(xd.intersection(xn), set([]))

 def test_xdict_key_difference_when_none_present(self):
     xd = XDict({'one': 1, 'two': 1, 'three': 3})
     xn = XDict({'one': 1, 'two': 1, 'three': 3})
     self.assertEqual(xd.difference(xn), set([])) # returns empty set

 def test_xdict_builtin_dictionary_method(self):
     xd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
     nd = {'another': 'value2'}
     xd.update(nd) # test a built in dictionary method on an XDict
     self.assertEqual(xd['another'], 'value2')
     self.assertEqual(xd.attrkey, 'attrval') # confirm that attribute remains

 def test_xdict_add_attribute(self):
     xd = XDict({'key': 'value'}, {'attrkey': 'attrval'})
     xd.newatt = 'the test'
     self.assertEqual(xd.newatt, 'the test')

 def test_xdict_equals_newobj_diff_dicttypes(self):
     xd = XDict({'key': '1'}, {'attrkey': 'attrval'})
     xn = XDict({'key': 1}, {'attrkey': 'attrval'})
     self.assertFalse(xd.equals(xn))
     self.assertFalse(xd == xn)
     self.assertTrue(xd != xn)

 def test_xdict_equals_newobj_diffattr_number(self):
     xd = XDict({'key': 'value'}, {'attrkey': 'attrval', 'another': 'test'})
     xn = XDict({'key': 'value'}, {'attrkey': 'attrval'})
     self.assertFalse(xd.equals(xn))
     self.assertFalse(xd == xn)
     self.assertTrue(xd != xn)

 def test_xdict_val_count_ci(self):
     xd = XDict({'one': 'TEST', 'two': 'Test', 'int': 1})
     self.assertEqual(xd.val_count_ci('test'), 2)

 def test_xdict_key_difference(self):
     xd = XDict({'one': 1, 'two': 1, 'three': 3})
     xn = XDict({'one': 1, 'twotwo': 1, 'three': 3})
     self.assertEqual(len(xd.difference(xn)), 1)
     self.assertEqual(xd.difference(xn), set(['two']))

 def test_xdict_max_val_strings(self):
     xd = XDict({'one': '1', 'two': '2', 'three': '3'})
     value, key = xd.max_val()
     self.assertEqual(xd.max_val(), ('3', 'three')) # returns a tuple
     self.assertEqual(value, '3')
     self.assertEqual(key, 'three')

 def test_xdict_key_intersection(self):
     xd = XDict({'one': 1, 'two': 1, 'three': 3})
     xn = XDict({'one': 1, 'twotwo': 1, 'three': 3})
     self.assertEqual(len(xd.intersection(xn)), 2)
     self.assertEqual(xd.intersection(xn), set(['one', 'three']))