def test_validate_concentrations(self):
        """Tests validation of conecntrations against cluster space."""

        # Test with dict
        concentrations = {'Au': 0.1, 'Pd': 0.9}
        ret_conc = _validate_concentrations(concentrations, self.cs)
        self.assertIsInstance(ret_conc, dict)
        self.assertEqual(len(ret_conc), 1)
        self.assertIsInstance(ret_conc['A'], dict)
        self.assertEqual(len(ret_conc['A']), 2)
        for el in concentrations.keys():
            self.assertIn(el, ret_conc['A'])
            self.assertAlmostEqual(ret_conc['A'][el], concentrations[el])

        # Test with list of dicts
        list_concentrations = {'A': concentrations}
        ret_conc = _validate_concentrations(list_concentrations, self.cs)
        self.assertIsInstance(ret_conc, dict)
        self.assertEqual(len(ret_conc), 1)
        self.assertIsInstance(ret_conc['A'], dict)
        self.assertEqual(len(ret_conc['A']), 2)
        for el in concentrations.keys():
            self.assertIn(el, ret_conc['A'])
            self.assertAlmostEqual(ret_conc['A'][el], concentrations[el])

        concentrations = {'Au': 0.1, 'Pd': 0.7}
        with self.assertRaises(ValueError) as cm:
            _validate_concentrations(concentrations, self.cs)
        self.assertIn('Concentrations must sum up to 1', str(cm.exception))

        concentrations = {'Au': 1.0}
        with self.assertRaises(ValueError) as cm:
            _validate_concentrations(concentrations, self.cs)
        self.assertIn('not the same as those in the specified',
                      str(cm.exception))
    def test_validate_concentrations(self):
        """Tests validation of conecntrations against cluster space."""
        concentrations = {'Au': 0.5, 'Pd': 0.5}
        _validate_concentrations(concentrations, self.cs)

        concentrations = {'Au': 0.1, 'Pd': 0.7}
        with self.assertRaises(ValueError) as cm:
            _validate_concentrations(concentrations, self.cs)
        self.assertIn('Concentrations must sum up to 1', str(cm.exception))

        concentrations = {'Au': 0.1, 'Pd': 0.8, 'Cu': 0.1}
        with self.assertRaises(ValueError) as cm:
            _validate_concentrations(concentrations, self.cs)
        self.assertIn('not the same as those in the specified',
                      str(cm.exception))

        concentrations = {'Au': 1.0}
        with self.assertRaises(ValueError) as cm:
            _validate_concentrations(concentrations, self.cs)
        self.assertIn('not the same as those in the specified',
                      str(cm.exception))
    def test_validate_concentrations(self):
        """Tests validation of conecntrations against cluster space."""
        concentrations = {
            'A': {
                'Au': 0.2,
                'Pd': 0.6,
                'Cu': 0.2
            },
            'B': {
                'H': 0.8,
                'V': 0.2
            }
        }
        ret_conc = _validate_concentrations(concentrations, self.cs)
        self.assertIsInstance(ret_conc, dict)
        self.assertEqual(len(ret_conc), 2)
        self.assertIsInstance(ret_conc['A'], dict)

        concentrations = {
            'A': {
                'Au': 0.1,
                'Pd': 0.7,
                'Cu': 0.2
            },
            'B': {
                'H': 0.0,
                'V': 0.9
            }
        }
        with self.assertRaises(ValueError) as cm:
            _validate_concentrations(concentrations, self.cs)
        self.assertIn('Concentrations must sum up to 1', str(cm.exception))

        concentrations = {'A': {'Au': 0.5, 'Pd': 0.5}, 'B': {'Cu': 1}}
        with self.assertRaises(ValueError) as cm:
            _validate_concentrations(concentrations, self.cs)
        self.assertIn('not the same as those in the specified',
                      str(cm.exception))

        concentrations = {'Au': 2 / 6, 'Pd': 1 / 6, 'Cu': 3 / 6}
        with self.assertRaises(ValueError) as cm:
            _validate_concentrations(concentrations, self.cs)
        self.assertIn("A sublattice (B: ['H', 'V']) is missing",
                      str(cm.exception))
    def test_validate_concentrations(self):
        """Tests validation of conecntrations against cluster space."""
        concentrations = {'Au': 0.4, 'Pd': 0.6}
        ret_conc = _validate_concentrations(concentrations, self.cs)
        self.assertIsInstance(ret_conc, dict)
        self.assertEqual(len(ret_conc), 1)
        self.assertIsInstance(ret_conc['A'], dict)

        concentrations = {'Au': 0.1, 'Pd': 0.8}
        with self.assertRaises(ValueError) as cm:
            _validate_concentrations(concentrations, self.cs)
        self.assertIn('Concentrations must sum up to 1', str(cm.exception))

        concentrations = {'A': {'Au': 0.4, 'Pd': 0.6}, 'B': {'Au': 1.0}}
        ret_conc = _validate_concentrations(concentrations, self.cs)
        self.assertIsInstance(ret_conc, dict)
        self.assertEqual(len(ret_conc), 2)
        self.assertIsInstance(ret_conc['A'], dict)

        concentrations = {'A': {'Au': 0.5, 'Pd': 0.5}, 'B': {'C': 1}}
        with self.assertRaises(ValueError) as cm:
            _validate_concentrations(concentrations, self.cs)
        self.assertIn('not the same as those in the specified',
                      str(cm.exception))