# pygitversionhelper (c) by chacha
#
# pygitversionhelper  is licensed under a
# Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International Unported License.
#
# You should have received a copy of the license along with this
# work.  If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.

import unittest

import tempfile
import os
import pathlib
import re
import copy
import time
import subprocess

print(__name__)
print(__package__)

from src import pygitversionhelper

HelperRegex=r"^(?P<MAJ>\d+)\.(?P<MIN>\d+)\.(?P<PATCH>\d+)([\.\-\+])?(?:.*)?"

class Test_gitversionhelper(unittest.TestCase):
    def setUp(self):
        self.TmpWorkingDir=tempfile.TemporaryDirectory()
        self.TmpWorkingDirPath=pathlib.Path(self.TmpWorkingDir.name)
        os.chdir(self.TmpWorkingDirPath)
        os.system("git init")
        os.system('git config --local user.name "john doe"')
        os.system('git config --local user.email "john@doe.org"')
        
    def _test_version_readback(self,tag:str,**kwargs):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")

        os.system("git add .")
        os.system("git commit -m  \"first commit\"")
        os.system(f"git tag {tag}")

        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(**kwargs)
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self.assertIsInstance(_v.raw, str)
        self.assertEqual(_v.raw, tag)
        self.assertIsInstance(_v.major, int)
        self.assertIsInstance(_v.minor, int)
        self.assertIsInstance(_v.patch, int)
        self.assertIsInstance(_v.pre_count, int)
        self.assertIsInstance(_v.post_count, int)
        

        _m = re.match(HelperRegex, tag)
        self.assertEqual(int(_m.group("MAJ")),_v.major)
        self.assertEqual(int(_m.group("MIN")),_v.minor)
        self.assertEqual(int(_m.group("PATCH")),_v.patch)
               
        return _v
        
    def _test_version_format(self,_v:pygitversionhelper.gitversionhelper.version.MetaVersion,tag:str,**kwargs):
        _f=_v.doFormatVersion(**kwargs)
        self.assertRegex(_f,HelperRegex)
        self.assertEqual(_f, tag)
        
    def _test_version_readback_simple(self,tag:str,**kwargs):   
        _v=self._test_version_readback(tag,**kwargs)
        self._test_version_format(_v,tag,**kwargs)

    def test_nominal__version__formated_output(self):
        _v = pygitversionhelper.gitversionhelper.version.MetaVersion("PEP440",
                                                                     1,
                                                                     0,
                                                                     0,
                                                                     0,
                                                                     0,
                                                                     "1.0.0")
        self.assertEqual("1.0.1", _v.bump(formated_output=True))
        self.assertEqual("2.0.0", _v.bump(formated_output=True,bump_type="major"))
        
    def test_nominal__version__auto_1(self):
        self._test_version_readback_simple("0.0.1")
    def test_nominal__version__auto_2(self):
        self._test_version_readback_simple("0.0.2")
    def test_nominal__version__auto_3(self):
        self._test_version_readback_simple("0.1.0")
    def test_nominal__version__auto_4(self):
        self._test_version_readback_simple("0.1.1")
    def test_nominal__version__auto_5(self):
        self._test_version_readback_simple("1.0.0")
    def test_nominal__version__auto_6(self):
        self._test_version_readback_simple("1.1.0")
    def test_nominal__version__auto_7(self):
        self._test_version_readback_simple("1.2.0")
    def test_nominal__version__auto_8(self):
        self._test_version_readback_simple("1.1.1")
    def test_nominal__version__auto_9(self):
        self._test_version_readback_simple("1.2.1")
    def test_nominal__version__auto_PEP440_post(self):
        self._test_version_readback_simple("1.2.1.post1")
    def test_nominal__version__auto_PEP440_pre(self):
        self._test_version_readback_simple("1.2.1.pre1")
    def test_nominal__version__auto_PEP440_post_2(self):
        self._test_version_readback_simple("1.2.1.post10")
    def test_nominal__version__auto_PEP440_pre_2(self):
        self._test_version_readback_simple("1.2.1.pre10")
        
    def test_nominal__version__auto_SemVer_post(self):
        self._test_version_readback_simple("1.2.1+post.1")
    def test_nominal__version__auto_SemVer_pre(self):
        self._test_version_readback_simple("1.2.1-pre.1")
    def test_nominal__version__auto_SemVer_post_2(self):
        self._test_version_readback_simple("1.2.1+post.10")
    def test_nominal__version__auto_Semver_pre_2(self):
        self._test_version_readback_simple("1.2.1-pre.10")

    def test_nominal__version__PEP440_1(self):
        self._test_version_readback_simple("0.0.1",version_std="PEP440")
    def test_nominal__version__PEP440_2(self):
        self._test_version_readback_simple("0.0.2",version_std="PEP440")
    def test_nominal__version__PEP440_3(self):
        self._test_version_readback_simple("0.1.0",version_std="PEP440")
    def test_nominal__version__PEP440_4(self):
        self._test_version_readback_simple("0.1.1",version_std="PEP440")
    def test_nominal__version__PEP440_5(self):
        self._test_version_readback_simple("1.0.0",version_std="PEP440")
    def test_nominal__version__PEP440_6(self):
        self._test_version_readback_simple("1.1.0",version_std="PEP440")
    def test_nominal__version__PEP440_7(self):
        self._test_version_readback_simple("1.2.0",version_std="PEP440")
    def test_nominal__version__PEP440_8(self):
        self._test_version_readback_simple("1.1.1",version_std="PEP440")
    def test_nominal__version__PEP440_9(self):
        self._test_version_readback_simple("1.2.1",version_std="PEP440")
    def test_nominal__version__PEP440_post(self):
        self._test_version_readback_simple("1.2.1.post1",version_std="PEP440")
    def test_nominal__version__PEP440_pre(self):
        self._test_version_readback_simple("1.2.1.pre1",version_std="PEP440")
    def test_nominal__version__PEP440_post_2(self):
        self._test_version_readback_simple("1.2.1.post10",version_std="PEP440")
    def test_nominal__version__PEP440_pre_2(self):
        self._test_version_readback_simple("1.2.1.pre10",version_std="PEP440")

    def test_nominal__version__SemVer_1(self):
        self._test_version_readback_simple("0.0.1",version_std="SemVer")
    def test_nominal__version__SemVer_2(self):
        self._test_version_readback_simple("0.0.2",version_std="SemVer")
    def test_nominal__version__SemVer_3(self):
        self._test_version_readback_simple("0.1.0",version_std="SemVer")
    def test_nominal__version__SemVer_4(self):
        self._test_version_readback_simple("0.1.1",version_std="SemVer")
    def test_nominal__version__SemVer_5(self):
        self._test_version_readback_simple("1.0.0",version_std="SemVer")
    def test_nominal__version__SemVer_6(self):
        self._test_version_readback_simple("1.1.0",version_std="SemVer")
    def test_nominal__version__SemVer_7(self):
        self._test_version_readback_simple("1.2.0",version_std="SemVer")
    def test_nominal__version__SemVer_8(self):
        self._test_version_readback_simple("1.1.1",version_std="SemVer")
    def test_nominal__version__SemVer_9(self):
        self._test_version_readback_simple("1.2.1",version_std="SemVer")
    def test_nominal__version__SemVer_post(self):
        self._test_version_readback_simple("1.2.1+post.1",version_std="SemVer")
    def test_nominal__version__SemVer_pre(self):
        self._test_version_readback_simple("1.2.1-pre.1",version_std="SemVer")
    def test_nominal__version__SemVer_post_2(self):
        self._test_version_readback_simple("1.2.1+post.10",version_std="SemVer")
    def test_nominal__version__SemVer_pre_2(self):
        self._test_version_readback_simple("1.2.1-pre.10",version_std="SemVer")
        
    def test_nominal__version__post_PEP440_to_SemVer(self):
        _v=self._test_version_readback("1.2.1.post10",version_std="PEP440")
        self._test_version_format(_v,"1.2.1+post.10",version_std="SemVer")
        
    def test_nominal__version__post_SemVer_to_PEP440(self):
        _v=self._test_version_readback("1.2.1+post.10",version_std="SemVer")
        self._test_version_format(_v,"1.2.1.post10",version_std="PEP440")

    def test_nominal__version__pre_PEP440_to_SemVer(self):
        _v=self._test_version_readback("1.2.1.pre10",version_std="PEP440")
        self._test_version_format(_v,"1.2.1-pre.10",version_std="SemVer")
        
    def test_nominal__version__pre_SemVer_to_PEP440(self):
        _v=self._test_version_readback("1.2.1-pre.10",version_std="SemVer")
        self._test_version_format(_v,"1.2.1.pre10",version_std="PEP440")
              
    def test_nominal__version__post_SemVer_nonum(self):
        _v=self._test_version_readback("1.2.1+post",version_std="SemVer")
        self._test_version_format(_v,"1.2.1+post.1",version_std="SemVer")
        
    def test_nominal__version__post_SemVer_nonum_random(self):
        _v=self._test_version_readback("1.2.1+toto",version_std="SemVer")
        self._test_version_format(_v,"1.2.1+post.1",version_std="SemVer")
        
    def test_nominal__version__pre_SemVer_nonum(self):
        _v=self._test_version_readback("1.2.1-pre",version_std="SemVer")
        self._test_version_format(_v,"1.2.1-pre.1",version_std="SemVer")
        
    def test_nominal__version__pre_SemVer_nonum_random(self):
        _v=self._test_version_readback("1.2.1-toto",version_std="SemVer")
        self._test_version_format(_v,"1.2.1-pre.1",version_std="SemVer")
        
    def test_nominal__version___pump_SemVer(self):
        _v = self._test_version_readback("1.0.0",version_std="SemVer")
        
        _v = _v.bump()
        self.assertIsInstance(_v.raw, str)
        self.assertIsInstance(_v.major, int)
        self.assertIsInstance(_v.minor, int)
        self.assertIsInstance(_v.patch, int)
        self.assertIsInstance(_v.pre_count, int)
        self.assertIsInstance(_v.post_count, int)
        self.assertEqual(_v.raw, "1.0.1")
        self.assertEqual(_v.major, 1)
        self.assertEqual(_v.minor, 0)
        self.assertEqual(_v.patch, 1)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "1.0.1")
        
        _v = _v.bump(bump_type="patch")
        self.assertEqual(_v.raw, "1.0.2")
        self.assertEqual(_v.major, 1)
        self.assertEqual(_v.minor, 0)
        self.assertEqual(_v.patch, 2)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "1.0.2")
        
        _v = _v.bump(bump_type="minor")
        self.assertEqual(_v.raw, "1.1.2")
        self.assertEqual(_v.major, 1)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 2)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "1.1.2")
        
        _v = _v.bump(bump_type="major")
        self.assertEqual(_v.raw, "2.1.2")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 2)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.2")
        
        _v = _v.bump(bump_type="dev")
        self.assertEqual(_v.raw, "2.1.2+post.1")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 2)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 1)
        self.assertEqual(_v.doFormatVersion(), "2.1.2+post.1")
        
        _v = _v.bump(bump_type="dev")
        self.assertEqual(_v.raw, "2.1.2+post.2")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 2)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 2)
        self.assertEqual(_v.doFormatVersion(), "2.1.2+post.2")
        
        _v = _v.bump(bump_type="patch")
        self.assertEqual(_v.raw, "2.1.3")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 3)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.3")     
        
        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
        self.assertEqual(_v.raw, "2.1.4-pre.1")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 4)
        self.assertEqual(_v.pre_count, 1)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.4-pre.1")
        
        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
        self.assertEqual(_v.raw, "2.1.4-pre.2")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 4)
        self.assertEqual(_v.pre_count, 2)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.4-pre.2")
        
        _v = _v.bump(bump_type="dev",bump_dev_strategy="post")
        self.assertEqual(_v.raw, "2.1.4-pre.3")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 4)
        self.assertEqual(_v.pre_count, 3)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.4-pre.3")
        
        _v = _v.bump(bump_type="patch")
        self.assertEqual(_v.raw, "2.1.5")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 5)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.5")  
        
        _v = _v.bump(bump_type="dev",bump_dev_strategy="post")
        self.assertEqual(_v.raw, "2.1.5+post.1")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 5)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 1)
        self.assertEqual(_v.doFormatVersion(), "2.1.5+post.1")
        
        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
        self.assertEqual(_v.raw, "2.1.5+post.2")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 5)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 2)
        self.assertEqual(_v.doFormatVersion(), "2.1.5+post.2")

    def test_nominal__version___pump_PEP440(self):
        _v = self._test_version_readback("1.0.0",version_std="PEP440")
        
        _v = _v.bump()
        self.assertIsInstance(_v.raw, str)
        self.assertIsInstance(_v.major, int)
        self.assertIsInstance(_v.minor, int)
        self.assertIsInstance(_v.patch, int)
        self.assertIsInstance(_v.pre_count, int)
        self.assertIsInstance(_v.post_count, int)
        self.assertEqual(_v.raw, "1.0.1")
        self.assertEqual(_v.major, 1)
        self.assertEqual(_v.minor, 0)
        self.assertEqual(_v.patch, 1)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "1.0.1")
        
        _v = _v.bump(bump_type="patch")
        self.assertEqual(_v.raw, "1.0.2")
        self.assertEqual(_v.major, 1)
        self.assertEqual(_v.minor, 0)
        self.assertEqual(_v.patch, 2)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "1.0.2")
        
        _v = _v.bump(bump_type="minor")
        self.assertEqual(_v.raw, "1.1.2")
        self.assertEqual(_v.major, 1)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 2)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "1.1.2")
        
        _v = _v.bump(bump_type="major")
        self.assertEqual(_v.raw, "2.1.2")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 2)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.2")
        
        _v = _v.bump(bump_type="dev")
        self.assertEqual(_v.raw, "2.1.2.post1")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 2)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 1)
        self.assertEqual(_v.doFormatVersion(), "2.1.2.post1")
        
        _v = _v.bump(bump_type="dev")
        self.assertEqual(_v.raw, "2.1.2.post2")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 2)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 2)
        self.assertEqual(_v.doFormatVersion(), "2.1.2.post2")
        
        _v = _v.bump(bump_type="patch")
        self.assertEqual(_v.raw, "2.1.3")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 3)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.3")     
        
        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
        self.assertEqual(_v.raw, "2.1.4.pre1")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 4)
        self.assertEqual(_v.pre_count, 1)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.4.pre1")
        
        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
        self.assertEqual(_v.raw, "2.1.4.pre2")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 4)
        self.assertEqual(_v.pre_count, 2)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.4.pre2")
        
        _v = _v.bump(bump_type="dev",bump_dev_strategy="post")
        self.assertEqual(_v.raw, "2.1.4.pre3")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 4)
        self.assertEqual(_v.pre_count, 3)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.4.pre3")
        
        _v = _v.bump(bump_type="patch")
        self.assertEqual(_v.raw, "2.1.5")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 5)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 0)
        self.assertEqual(_v.doFormatVersion(), "2.1.5")  
        
        _v = _v.bump(bump_type="dev",bump_dev_strategy="post")
        self.assertEqual(_v.raw, "2.1.5.post1")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 5)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 1)
        self.assertEqual(_v.doFormatVersion(), "2.1.5.post1")
        
        _v = _v.bump(bump_type="dev",bump_dev_strategy="pre-patch")
        self.assertEqual(_v.raw, "2.1.5.post2")
        self.assertEqual(_v.major, 2)
        self.assertEqual(_v.minor, 1)
        self.assertEqual(_v.patch, 5)
        self.assertEqual(_v.pre_count, 0)
        self.assertEqual(_v.post_count, 2)
        self.assertEqual(_v.doFormatVersion(), "2.1.5.post2")
        
    def test_nominal__version___SemVer_zeroRev(self):
        _v=self._test_version_readback("0.0.0",version_std="SemVer")
        self._test_version_format(_v,"0.0.0",version_std="SemVer")
        
    def test_nominal__version___PEP440_zeroRev(self):
        _v=self._test_version_readback("0.0.0",version_std="PEP440")
        self._test_version_format(_v,"0.0.0",version_std="PEP440")
        

    def test_nominal__version___PEP440_noRev_noTag(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")

        os.system("git add .")
        os.system("git commit -m  \"first commit\"")
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.0",version_std="PEP440")
        self.assertEqual(_v.raw, "0.1.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,0)
        
    def test_nominal__version___SemVer_noRev_noTag(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")

        os.system("git add .")
        os.system("git commit -m  \"first commit\"")
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="SemVer")
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.0",version_std="SemVer")
        self.assertEqual(_v.raw, "0.1.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,0)
        
    def test_nominal__version___AUTO_noRev_noTag(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")

        os.system("git add .")
        os.system("git commit -m  \"first commit\"")
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.0")
        self.assertEqual(_v.raw, "0.1.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,0)

    def test_nominal__version___AUTO_bump_commits(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"first commit\"")
        os.system(f"git tag 0.2.0")
        
        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.2.0") 
        self.assertEqual(_v.raw, "0.2.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,2)
        self.assertEqual(_v.patch,0)
        self.assertEqual(_v.pre_count,0)
        self.assertEqual(_v.post_count,0)    
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue22")  
        os.system("git add .")
        os.system("git commit -m  \"2nd commit\"")

        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.2.1")    
        self.assertEqual(_v.raw, "0.2.1")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,2)
        self.assertEqual(_v.patch,1)
        self.assertEqual(_v.pre_count,0)
        self.assertEqual(_v.post_count,0) 

        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue223")  
        os.system("git add .")
        os.system("git commit -m  \"3rd commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue224")  
        os.system("git add .")
        os.system("git commit -m  \"4th commit\"")
        
        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.2.3")  
        self.assertEqual(_v.raw, "0.2.3")        
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,2)
        self.assertEqual(_v.patch,3)
        self.assertEqual(_v.pre_count,0)
        self.assertEqual(_v.post_count,0)
         
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue225")  
        os.system("git add .")
        os.system("git commit -m  \"5th commit\"")  
        
        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev")
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self.assertIsInstance(_v.raw, str)
        self._test_version_format(_v,"0.2.0+post.4")  
        self.assertEqual(_v.raw, "0.2.0+post.4")        
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,2)
        self.assertEqual(_v.patch,0)
        self.assertEqual(_v.pre_count,0)
        self.assertEqual(_v.post_count,4)
        
        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-patch")
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.2.1-pre.4")  
        self.assertEqual(_v.raw, "0.2.1-pre.4")        
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,2)
        self.assertEqual(_v.patch,1)
        self.assertEqual(_v.pre_count,4)
        self.assertEqual(_v.post_count,0) 
        
        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-minor")
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.3.0-pre.4") 
        self.assertEqual(_v.raw, "0.3.0-pre.4")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,3)
        self.assertEqual(_v.patch,0)
        self.assertEqual(_v.pre_count,4)
        self.assertEqual(_v.post_count,0)
          
        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-major")
        
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"1.0.0-pre.4")   
        self.assertEqual(_v.raw, "1.0.0-pre.4")        
        self.assertEqual(_v.major,1)
        self.assertEqual(_v.minor,0)
        self.assertEqual(_v.patch,0)
        self.assertEqual(_v.pre_count,4)
        self.assertEqual(_v.post_count,0)
        
    def test_nominal__version___custom_format(self):
        _v=self._test_version_readback("0.1.1",version_std="PEP440")
        
        self.assertEqual("V_0_1_1____",_v.doFormatVersion(output_format="V_{major}_{minor}_{patch}____{revcount}"))
        self.assertEqual("V_0_1",_v.doFormatVersion(output_format="V_{major}_{minor}"))
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue225")  
        os.system("git add .")
        os.system("git commit -m  \"5th commit\"")  
        
        self.assertEqual("V_1_0",pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-major").doFormatVersion(output_format="V_{major}_{minor}"))
        self.assertEqual("V_1_0",pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-major",output_format="V_{major}_{minor}",formated_output=True))


    def test_nominal__git__emptyrepo(self):
        _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.0")  
        self.assertEqual(_v.raw, "0.1.0")
        
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,0)
        self.assertEqual(_v.pre_count,0)
        self.assertEqual(_v.post_count,0)
        
    def test_defect__git__dirty(self):
        _v=self._test_version_readback("0.1.1",version_std="PEP440")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue225") 
             
        with self.assertRaises(pygitversionhelper.gitversionhelper.repository.repositoryDirty) :
            pygitversionhelper.gitversionhelper.version.getCurrentVersion()
            

    def test_defect__version_post_and_pre_output(self):
        _v = pygitversionhelper.gitversionhelper.version.MetaVersion("PEP440",
                                                                     0,
                                                                     0,
                                                                     1,
                                                                     1,
                                                                     1,
                                                                     "0.0.1.pre1.post1")
        with self.assertRaises(pygitversionhelper.gitversionhelper.version.PreAndPostVersionUnsupported) :
            _v.doFormatVersion()
            
        _v = pygitversionhelper.gitversionhelper.version.MetaVersion("SemVer",
                                                                     0,
                                                                     0,
                                                                     1,
                                                                     1,
                                                                     1,
                                                                     "0.0.1-pre.1+post.1")
        with self.assertRaises(pygitversionhelper.gitversionhelper.version.PreAndPostVersionUnsupported) :
            _v.doFormatVersion()
            
    def test_defect__version_post_and_pre_parse(self):
        with self.assertRaises(pygitversionhelper.gitversionhelper.version.PreAndPostVersionUnsupported) :
            pygitversionhelper.gitversionhelper.version._parseTag("0.0.1.pre1.post1")

            
    def test_defect__git__wrongargument_sortargs(self):
        with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) :
            pygitversionhelper.gitversionhelper.tag.getTags(sort="toto")
            
    def test_defect__git__notagfound(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"first commit\"")
        with self.assertRaises(pygitversionhelper.gitversionhelper.tag.tagNotFound) :
            pygitversionhelper.gitversionhelper.tag.getLastTag()
            
    """ This test is impossible to do because current implementation can only return one tag
    def test_defect__git_multipletagsfound(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"first commit\"")
        os.system(f"git tag 0.1.0")
        os.system(f"git tag 0.2.0")
        with self.assertRaises(pygitversionhelper.gitversionhelper.tag.moreThanOneTag) :
            pygitversionhelper.gitversionhelper.tag.getLastTag(same_branch=True)
    """

    def test_defect__wrongargument_bump_type(self):
        _v=self._test_version_readback("0.1.1",version_std="PEP440")
        with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) :
            pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="toto")

    def test_defect__wrongargument_bump_dev_strategy(self):
        _v=self._test_version_readback("0.1.1",version_std="PEP440")
        with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) :
            pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_dev_strategy="toto")

    def test_nominal__tag__getDistanceFromTag(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.2.0")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue1")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue2")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.3.0")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue3")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue4")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        self.assertEqual(2,pygitversionhelper.gitversionhelper.tag.getDistanceFromTag())
        self.assertEqual(4,pygitversionhelper.gitversionhelper.tag.getDistanceFromTag("0.2.0"))
        
    def test_nominal__tag__getTags(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.2.0")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue1")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue2")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.3.0")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue3")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue4")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue5")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.3.1")
        
        self.assertEqual(set(["0.3.0","0.2.0","0.3.1"]),set(pygitversionhelper.gitversionhelper.tag.getTags()))
        
    def test_nominal__tag__getTags_two_branch(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.2.0")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue1")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue2")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.3.0")
        
        os.system("git checkout -b dev")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue3")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue4")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue5")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.3.1")
        
        self.assertEqual(set(["0.3.0","0.2.0","0.3.1"]),set(pygitversionhelper.gitversionhelper.tag.getTags()))
        
    def test_nominal__tag__getTags_two_branch_samebranch(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.2.0")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue1")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue2")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.3.0")
        
        os.system("git checkout -b dev")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue3")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue4")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue5")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.3.1")
        
        self.assertEqual(set(["0.3.0","0.2.0","0.3.1"]),set(pygitversionhelper.gitversionhelper.tag.getTags(same_branch=True)))
        
        os.system("git switch master")
        
        self.assertEqual(set(["0.3.0","0.2.0"]),set(pygitversionhelper.gitversionhelper.tag.getTags(same_branch=True)))
        
        os.system("git switch dev")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue4")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.3.2")
        
        self.assertEqual(set(["0.3.0","0.2.0","0.3.1","0.3.2"]),set(pygitversionhelper.gitversionhelper.tag.getTags(same_branch=True)))
        self.assertEqual(set(["0.3.0","0.2.0","0.3.1","0.3.2"]),set(pygitversionhelper.gitversionhelper.tag.getTags()))
        
        os.system("git switch master")
        
        self.assertEqual(set(["0.3.0","0.2.0"]),set(pygitversionhelper.gitversionhelper.tag.getTags(same_branch=True)))
        self.assertEqual(set(["0.3.0","0.2.0","0.3.1","0.3.2"]),set(pygitversionhelper.gitversionhelper.tag.getTags()))
        
    def test_nominal__tag__getLastTag_two_branches(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"first commit\"")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue1")
        os.system("git add .")
        os.system("git commit -m  \"2nd commit\"")
        os.system(f"git tag 0.1.0")
        
        os.system("git checkout -b dev")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue2")
        os.system("git add .")
        os.system("git commit -m  \"3rd commit\"")
        os.system(f"git tag 0.2.0")
        
        """
        print("===")
        os.system(f"git status")
        print("===")
        os.system(f"git describe --tags --abbrev=0")
        print("===")
        os.system(f"git rev-list --all")
        print("===")
        os.system(f"git rev-list --tags")
        print("===")
        os.system(f"git log --oneline --decorate=short")
        print("===")
        os.system(f"git describe --tags")
        print("===")
        """
              
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.2.0",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.2.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,2)
        self.assertEqual(_v.patch,0)    
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue3")
        os.system("git add .")
        os.system("git commit -m  \"3rd commit\"")
        os.system(f"git tag 0.3.0")
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.3.0",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.3.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,3)
        self.assertEqual(_v.patch,0)   
        
        os.system("git switch master")
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.3.0",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.3.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,3)
        self.assertEqual(_v.patch,0)  
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440",same_branch=True)
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.0",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.1.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,0)  
        
        os.system("git merge --no-ff dev -m \"merge dev into master\"")
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440",same_branch=True)
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.0",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.1.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,0) 
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.3.0",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.3.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,3)
        self.assertEqual(_v.patch,0)   
        
        os.system(f"git tag 0.4.0")
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440",same_branch=True)
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.4.0",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.4.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,4)
        self.assertEqual(_v.patch,0) 
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.4.0",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.4.0")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,4)
        self.assertEqual(_v.patch,0)   
        
    def test_defect__tag__invalidtag(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue1")
        os.system("git add .")
        os.system("git commit -m  \"2nd commit\"")
        os.system(f"git tag INVALIDTAG")
        
        with self.assertRaises(pygitversionhelper.gitversionhelper.version.noValidVersion) :
            _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
            
            
        with self.assertRaises(pygitversionhelper.gitversionhelper.version.noValidVersion) :
            _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)

    def test_defect__tag__invalidtag_inbetween(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue1")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.0.1")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue2")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag INVALIDTAG")
        
        with self.assertRaises(pygitversionhelper.gitversionhelper.version.noValidVersion) :
            _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
            
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.0.1",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.0.1")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,0)
        self.assertEqual(_v.patch,1) 
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue3")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag INVALIDTAG2")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue4")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag INVALIDTA3")
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue4")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag INVALIDTA4")
        
        with self.assertRaises(pygitversionhelper.gitversionhelper.version.noValidVersion) :
            _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
            
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.0.1",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.0.1")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,0)
        self.assertEqual(_v.patch,1) 
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue5")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.1.2")

        _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.2",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.1.2")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,2) 
      
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.2",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.1.2")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,2) 

        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue6")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag INVALIDTA5")

        with self.assertRaises(pygitversionhelper.gitversionhelper.version.noValidVersion) :
            _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
            
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.2",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.1.2")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,2) 
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue7")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        os.system(f"git tag 0.1.3")
        
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.3",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.1.3")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,3) 
      
        _v = pygitversionhelper.gitversionhelper.version.getLastVersion(ignore_unknown_tags=True)
        self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
        self._test_version_format(_v,"0.1.3",version_std="PEP440")   
        self.assertEqual(_v.raw, "0.1.3")
        self.assertEqual(_v.major,0)
        self.assertEqual(_v.minor,1)
        self.assertEqual(_v.patch,3) 
        
    def test_nominal__commit_getLast(self):
        # sleeps are needed because commit date have a 1-sec accuracy :-/
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        time.sleep(1)

        initial_commit = pygitversionhelper.gitversionhelper.commit.getLast()
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue2")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        time.sleep(1)
        
        second_commit = pygitversionhelper.gitversionhelper.commit.getLast()
        
        self.assertNotEqual(initial_commit,second_commit) 
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue3")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        time.sleep(1)
        
        third_commit = pygitversionhelper.gitversionhelper.commit.getLast()
        
        self.assertNotEqual(initial_commit,third_commit) 
        self.assertNotEqual(second_commit,third_commit) 
        
        
        os.system("git checkout -b dev")

        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue4")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        time.sleep(1)
        
        fourth_commit = pygitversionhelper.gitversionhelper.commit.getLast()
        
        self.assertNotEqual(initial_commit,fourth_commit) 
        self.assertNotEqual(second_commit,fourth_commit) 
        self.assertNotEqual(third_commit,fourth_commit) 
        
        os.system("git switch master")
        
        fourth2_commit = pygitversionhelper.gitversionhelper.commit.getLast()
        self.assertEqual(fourth2_commit,fourth_commit) 
        
        fourth3_commit = pygitversionhelper.gitversionhelper.commit.getLast(same_branch=True)
        
        self.assertNotEqual(fourth3_commit,fourth_commit) 
        self.assertEqual(fourth3_commit,third_commit) 
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue5")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")
        time.sleep(1)
         
        fifth_commit = pygitversionhelper.gitversionhelper.commit.getLast()
        self.assertNotEqual(fifth_commit,fourth3_commit) 
        
        os.system("git switch dev")
        
        fifth2_commit = pygitversionhelper.gitversionhelper.commit.getLast()
        self.assertEqual(fifth2_commit,fifth_commit) 
        
        fifth2_commit = pygitversionhelper.gitversionhelper.commit.getLast(same_branch=True)
        self.assertEqual(fifth2_commit,fourth_commit) 
        
    def test_defect__commit_notfound(self):
        
        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound) :
            pygitversionhelper.gitversionhelper.commit.getLast()
            
        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound) :
            pygitversionhelper.gitversionhelper.commit.getLast(same_branch=True)
            
    def test_nominal__commit_getFromTag(self):
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")

        initial_commit = pygitversionhelper.gitversionhelper.commit.getLast()
        
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue2")
        os.system("git add .")
        os.system("git commit -m  \"commit2\"")
        os.system(f"git tag TAG")

        second_commit = pygitversionhelper.gitversionhelper.commit.getLast()
        self.assertNotEqual(second_commit,initial_commit) 
        second_commit2 = pygitversionhelper.gitversionhelper.commit.getFromTag("TAG")
        self.assertEqual(second_commit,second_commit2) 
        self.assertNotEqual(second_commit2,initial_commit) 
        
    def test_defect__commit_notfound2(self):
        
        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound) :
            pygitversionhelper.gitversionhelper.commit.getFromTag("TAG")
            
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system("git commit -m  \"commit\"")  
        
        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound) :
            pygitversionhelper.gitversionhelper.commit.getFromTag("TAG")
            
        os.system(f"git tag OTHER_TAG")
        
        with self.assertRaises(pygitversionhelper.gitversionhelper.commit.commitNotFound) :
            pygitversionhelper.gitversionhelper.commit.getFromTag("TAG")
            
    def test_nominal__commit_getMessage(self):
        commit_message="AAAABBB CCCCDDDD".replace('\r\n','\n').replace('\n','\r\n')
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        os.system(f"git commit -m  \"{commit_message}\"")
        commit = pygitversionhelper.gitversionhelper.commit.getLast()
        message = pygitversionhelper.gitversionhelper.commit.getMessage(commit)
        self.assertEqual(message,commit_message)
        
    def test_nominal__commit_getMessage2(self):
        commit_message="""AAAABBB
        CCCCDDDD
        -f dfsds dfsdfs  $""".replace('\r\n','\n').replace('\n','\r\n')

        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        
        cmd = "git commit -m".split()
        cmd.append(commit_message)
        subprocess.run(cmd,text=True,check=True)
        
        commit = pygitversionhelper.gitversionhelper.commit.getLast()
        message = pygitversionhelper.gitversionhelper.commit.getMessage(commit)

        self.assertEqual(message,commit_message)
        
    def test_nominal__commit_getMessagesSinceLastTag(self):
        commit_message1="1.1 update this"+ os.linesep+\
                       "1.1 fix that"    + os.linesep+\
                       "1.1 test"
        commit_message1=commit_message1.replace('\r\n','\n').replace('\n','\r\n')
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue")
        os.system("git add .")
        
        cmd = "git commit -m".split()
        cmd.append(commit_message1)
        subprocess.run(cmd,text=True,check=True)
        os.system(f"git tag 0.1.1")
        
        commit_message2="2.1 update this"+ os.linesep+\
                       "2.1 fix that"    + os.linesep+\
                       "2.1 test"
        commit_message2=commit_message2.replace('\r\n','\n').replace('\n','\r\n')
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue2")
        os.system("git add .")
        
        cmd = "git commit -m".split()
        cmd.append(commit_message2)
        subprocess.run(cmd,text=True,check=True) 
        
        commit_message3="3.1 update this"+ os.linesep+\
                       "3.1 fix that"    + os.linesep+\
                       "3.1 test"
        commit_message3=commit_message3.replace('\r\n','\n').replace('\n','\r\n')
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue3")
        os.system("git add .")
        
        cmd = "git commit -m".split()
        cmd.append(commit_message3)
        subprocess.run(cmd,text=True,check=True)   

        commit_message4="4.1 update this" + os.linesep+\
                        "4.1 fix that"    + os.linesep+\
                        "4.1 test"
        commit_message4=commit_message4.replace('\r\n','\n').replace('\n','\r\n')
        with  open("demofile.txt", "w+t") as tmpFile:
            tmpFile.write("testvalue4")
        os.system("git add .")
        
        cmd = "git commit -m".split()
        cmd.append(commit_message4)
        subprocess.run(cmd,text=True,check=True)  

        res = pygitversionhelper.gitversionhelper.commit.getMessagesSinceTag("0.1.1")
        self.assertEqual( [commit_message4,commit_message3,commit_message2],res)
        
        res = pygitversionhelper.gitversionhelper.commit.getMessagesSinceTag("0.1.1",merged_output=True)
        self.assertEqual( os.linesep.join([commit_message4,commit_message3,commit_message2]),res)
        
              
    def tearDown(self):
        os.chdir("/")
    
class Test_gitversionhelperNoRepo(unittest.TestCase):
    def setUp(self):
        self.TmpWorkingDir=tempfile.TemporaryDirectory()
        self.TmpWorkingDirPath=pathlib.Path(self.TmpWorkingDir.name)
        os.chdir(self.TmpWorkingDirPath)

    def test_defect__norepo(self):
        with self.assertRaises(pygitversionhelper.gitversionhelper.repository.notAGitRepository) :
            _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()

    def tearDown(self):
        os.chdir("/")