text: #!/pxrpythonsubst
  #
  # Copyright 2016 Pixar
  #
  # Licensed under the Apache License, Version 2.0 (the "Apache License")
  # with the following modification; you may not use this file except in
  # compliance with the Apache License and the following modification to it:
  # Section 6. Trademarks. is deleted and replaced with:
  #
  # 6. Trademarks. This License does not grant permission to use the trade
  #    names, trademarks, service marks, or product names of the Licensor
  #    and its affiliates, except as required to comply with Section 4(c) of
  #    the License and to reproduce the content of the NOTICE file.
  #
  # You may obtain a copy of the Apache License at
  #
  #     http://www.apache.org/licenses/LICENSE-2.0
  #
  # Unless required by applicable law or agreed to in writing, software
  # distributed under the Apache License with the above modification is
  # distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  # KIND, either express or implied. See the Apache License for the specific
  # language governing permissions and limitations under the Apache License.
  #
  
  from __future__ import print_function
  
  from pxr import Tf
  import unittest
  
  def Replace(tmpl, safe=False, **kw):
      ts = Tf.TemplateString(tmpl)
      result = ''
      if safe:
          result = ts.SafeSubstitute(kw)
      else:
          result = ts.Substitute(kw)
      print(repr(tmpl), ' -> ', repr(result))
      return result
  
  class TestTfTemplateString(unittest.TestCase):
      
      def test_TemplateString(self):
          self.assertTrue(Tf.TemplateString().valid)
          self.assertTrue(Tf.TemplateString('').valid)
          self.assertFalse(Tf.TemplateString('${}').valid)
          self.assertTrue(Tf.TemplateString('$').valid)
          self.assertTrue(Tf.TemplateString('$$').valid)
  
          self.assertFalse(Tf.TemplateString('${} ${} ${} ').valid)
          self.assertEqual(3, len(Tf.TemplateString('${} ${} ${} ').GetParseErrors()))
  
          self.assertFalse(Tf.TemplateString('${').valid)
          self.assertTrue(Tf.TemplateString('${').GetParseErrors())
  
          t = Tf.TemplateString('${foo}')
          self.assertEqual('${foo}', t.template)
          self.assertTrue(t.valid)
          self.assertFalse(t.GetParseErrors())
  
      def test_Substitute(self):
          self.assertEqual('value', Replace('$var', var='value'))
          self.assertEqual('valued', Replace('${var}d', var='value'))
          self.assertEqual('value-value', Replace('$var-value', var='value'))
          self.assertEqual('0000', Replace('$var$var$var$var', var='0'))
          self.assertEqual('0.0.0.0', Replace('${var}.${var}.${var}.${var}', var='0'))
  
          self.assertEqual("//brave/b952/shot/b952_17/b952_17.menva", 
                  Replace("//$unit/$prod/shot/$shot/$shot.menva",
                          unit='brave', prod='b952', shot='b952_17'))
  
          self.assertEqual("Please remit the $sum of $19.95", 
                  Replace("Please remit the $$sum of $$$sum", sum='19.95'))
  
          Replace("Unreplaced placeholders ${are} awesome", safe=True)
  
          with self.assertRaises(Tf.ErrorException):
              Replace("Unreplaced placeholders ${are} awesome")
  
          with self.assertRaises(Tf.ErrorException):
              Replace("Invalid characters in placeholders ${are not awesome")
  
          with self.assertRaises(Tf.ErrorException):
              Replace("Never stop ${quoting")
  
          with self.assertRaises(Tf.ErrorException):
              Replace("${}")
  
          with self.assertRaises(Tf.ErrorException):
              Replace("${  }")
  
  
      def test_EmptyMapping(self):
          t = Tf.TemplateString("//$unit/$prod/shot/$shot/$shot.menva")
          m = t.GetEmptyMapping()
          self.assertTrue('unit' in m)
          self.assertTrue('prod' in m)
          self.assertTrue('shot' in m)
  
  
          t = Tf.TemplateString("${ }")
          m = t.GetEmptyMapping()
          self.assertEqual(0, len(m))
          self.assertFalse(t.valid)
          self.assertNotEqual(0, len(t.GetParseErrors()))
  
  if __name__ == '__main__':
      unittest.main()
  
  