cleanup code

add more unittest

src/pygitversionhelper/gitversionhelper.py

@@ -7,13 +7,24 @@
 # work.  If not, see <https://creativecommons.org/licenses/by-nc-sa/4.0/>.
 
 """
+This project try to help doing handy operations with git when 
+dealing with project versioning and tags on python project -
+or at leat for project using PEP440 versionning or SemVer.
+
+Goal is to keep it compact and not covering too much other things.
+This is the reason it is one single file with nested classes.
+=> Design is on purpose poorly expandable to keep the scope maintainable.
+
+This library is maid for repository using tag as version.
+
+
 This module is the main gitversionhelper file, containing all the code.
-This project aim to be kept compact and focused on helping doing handy 
-things with git when it deal with project versions/tags.
+
+Read the read me for more information.
+Check the unittest s for usage samples.
 """
 
 from __future__ import annotations
-from typing import TYPE_CHECKING
 
 import os
 import subprocess
@@ -23,10 +34,6 @@ import logging
 
 from packaging.version import VERSION_PATTERN as packaging_VERSION_PATTERN
 
-# Only imports the below statements during type checking
-if TYPE_CHECKING:
-    from typing import Union
-
 def _exec(cmd: str, root: str | os.PathLike | None = None) -> list[str]:
     """
     helper function to handle system cmd execution
@@ -37,15 +44,13 @@ def _exec(cmd: str, root: str | os.PathLike | None = None) -> list[str]:
         a list of command's return lines
         
     """
-
-    p = subprocess.run(cmd.split(), text=True, cwd=root, capture_output=True, check=False)
+    p = subprocess.run(cmd.split(), text=True, cwd=root, capture_output=True, check=False, timeout=2)
     if re.search("not a git repository",p.stderr):
         raise gitversionhelper.repository.notAGitRepository()
     if re.search("fatal:",p.stderr):
-        raise gitversionhelper.unknownGITFatalError()
+        raise gitversionhelper.unknownGITFatalError(p.stderr)
     if int(p.returncode) < 0:
-        raise gitversionhelper.unknownGITError
-
+        raise gitversionhelper.unknownGITError(p.stderr)
     lines = p.stdout.splitlines()
     return [line.rstrip() for line in lines if line.rstrip()]
 
@@ -124,7 +129,7 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
             """
 
         @classmethod
-        def getTags(cls,sort:str = "version:refname") -> list[str]:
+        def getTags(cls,sort:str = "taggerdate",**kwargs) -> list[str]:
             """
             retrieve all tags from a repository
             Args:
@@ -132,23 +137,28 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
             Returns:
                 the tags list
             """
+            
             if sort not in cls.__validGitTagSort:
                 raise gitversionhelper.wrongArguments("sort option not in allowed list")
-            return _exec(f"git tag -l --sort={sort}")
+            
+            if ((cls.__OptDict["same_branch"] in kwargs) and (kwargs[cls.__OptDict["same_branch"]] is True)):
+                currentBranch = _exec("git rev-parse --abbrev-ref HEAD")
+                return list(reversed(_exec(f"git tag --merged {currentBranch[0]} --sort={sort}")))
+            return list(reversed(_exec(f"git tag -l --sort={sort}")))
 
         @classmethod
-        def getLastTag(cls,**kwargs) -> Union[str,None]:
+        def getLastTag(cls,**kwargs) -> str | None:
             """
             retrieve the last tag from a repository
-            Kwargs:
+            Keyword Arguments:
                 same_branch(bool): force searching only in the same branch
             Returns:
                 the tag
             """
             if ((cls.__OptDict["same_branch"] in kwargs) and (kwargs[cls.__OptDict["same_branch"]] is True)):
-                res = _exec("git describe --tags --abbrev=0")
+                res = _exec("git describe --tags --first-parent --abbrev=0")
             else:
-                res = _exec("git rev-list --tags --max-count=1")
+                res = _exec("git rev-list --tags --date-order --max-count=1")
                 if len(res)==1:
                     res = _exec(f"git describe --tags {res[0]}")
 
@@ -159,12 +169,12 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
             return res[0]
 
         @classmethod
-        def getDistanceFromTag(cls,tag=None,**kwargs) -> int:
+        def getDistanceFromTag(cls,tag:str=None,**kwargs) -> int:
             """
             retrieve the distance between HEAD and tag in the repository
             Arguments:
                 tag: reference tag, if None the most recent one will be used
-            Kwargs:
+            Keyword Arguments:
                 same_branch(bool): force searching only in the same branch
             Returns:
                 the tag
@@ -179,7 +189,8 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
         """
         __OptDict = {   "version_std":      "version_std",
                         "formated_output":  "formated_output",
-                        "output_format":    "output_format"}
+                        "output_format":    "output_format",
+                        "ignore_unknown_tags":  "ignore_unknown_tags"}
         DefaultInputFormat = "Auto"
         VersionStds    = { "SemVer" : { "regex" :               r"^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)"\
                                                                 r"(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)"\
@@ -208,20 +219,22 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
             """
             generic version object
             """
-            __OptDict                   = {  "bump_type":             "bump_type",
-                                             "bump_dev_strategy":     "bump_dev_strategy"}
+
+            __OptDict                   = {  "bump_type":            "bump_type",
+                                             "bump_dev_strategy":    "bump_dev_strategy",
+                                             "formated_output":      "formated_output"}
             DefaultBumpType             = "patch"
             BumpTypes                   = ["major","minor","patch","dev"]
             DefaultBumpDevStrategy      = "post"
             BumpDevStrategys            = ["post","pre-patch","pre-minor","pre-major"]
-            version_std                 = "None"
 
-            major: int      = 0
-            minor: int      = 1
-            patch: int      = 0
-            pre_count:int   = 0
-            post_count:int  = 0
-            raw:str         = "0.1.0"
+            version_std: str    = "None"
+            major: int          = 0
+            minor: int          = 1
+            patch: int          = 0
+            pre_count:int       = 0
+            post_count:int      = 0
+            raw:str             = "0.1.0"
 
             def __init__(self,version_std,major=0,minor=1,patch=0,pre_count=0,post_count=0,raw="0.1.0"): #pylint: disable=R0913
                 self.version_std = version_std
@@ -236,7 +249,7 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
             def _getBumpDevStrategy(cls,**kwargs) -> str:
                 """
                 get selected bump_dev_strategy
-                Kwargs:
+                Keyword Arguments:
                     bump_dev_strategy(str): the given bump_dev_strategy (can be None)
                 Returns:
                     Kwargs given bump_dev_strategy or the default one.
@@ -253,7 +266,7 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
             def _getBumpType(cls,**kwargs) -> str:
                 """
                 get selected bump_type
-                Kwargs:
+                Keyword Arguments:
                     bump_type(str): the given bump_type (can be None)
                 Returns:
                     Kwargs given bump_type or the default one.
@@ -266,10 +279,10 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
                         raise gitversionhelper.wrongArguments(f"invalid {cls.__OptDict['bump_type']} requested")
                 return BumpType
 
-            def bump(self,amount:int=1,**kwargs): # pylint: disable=R0912
+            def bump(self,amount:int=1,**kwargs) -> MetaVersion | str : # pylint: disable=R0912
                 """
                 bump the version to the next one
-                Kwargs:
+                Keyword Arguments:
                     bump_type(str): the given bump_type (can be None)
                     bump_dev_strategy(str): the given bump_dev_strategy (can be None)
                 Returns:
@@ -309,11 +322,13 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
                         _v.patch = _v.patch + amount
                     _v.pre_count=0
                     _v.post_count=0
-
                 _v.raw=_v.doFormatVersion(**kwargs)
+                
+                if ((self.__OptDict["formated_output"] in kwargs) and (kwargs[self.__OptDict["formated_output"]] is True)):
+                    return _v.doFormatVersion(**kwargs)
                 return _v
 
-            def doFormatVersion(self,**kwargs):
+            def doFormatVersion(self,**kwargs) -> str:
                 """
                 output a formated version string
                 Returns:
@@ -322,10 +337,10 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
                 return gitversionhelper.version.doFormatVersion(self,**kwargs)
 
         @classmethod
-        def _getVersionStd(cls,**kwargs):
+        def _getVersionStd(cls,**kwargs) -> str:
             """
             get selected version_std
-            Kwargs:
+            Keyword Arguments:
                 version_std(str): the given version_std (can be None)
             Returns:
                 Kwargs given version_std or the default one.
@@ -339,10 +354,10 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
             return VersionStd
 
         @classmethod
-        def getCurrentVersion(cls,**kwargs) -> Union[str,MetaVersion]:
+        def getCurrentVersion(cls,**kwargs) -> MetaVersion | str :
             """
             get the current version or bump depending of repository state
-            Kwargs:
+            Keyword Arguments:
                 version_std(str): the given version_std (can be None)
                 same_branch(bool): force searching only in the same branch
                 formated_output(bool) : output a formated version string
@@ -360,41 +375,32 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
 
             if not cls.__versionReseted:
                 amount  = gitversionhelper.tag.getDistanceFromTag(_v.raw,**kwargs)
-                _v = _v.bump(amount,**kwargs)
+                _v = _v.bump(amount,**saved_kwargs)
 
             if ((cls.__OptDict["formated_output"] in kwargs) and (kwargs[cls.__OptDict["formated_output"]] is True)):
                 return _v.doFormatVersion(**kwargs)
             return _v
 
         @classmethod
-        def getLastVersion(cls,**kwargs) -> Union[str,MetaVersion]: # pylint: disable=R0914, R0912, R0915
+        def _parseTag(cls,tag,**kwargs):
             """get the last version from tags
+            Arguments:
+                tag: the tag to be parsed
             Keyword Arguments:
                 version_std(str): the given version_std (can be None)
-                same_branch(bool): force searching only in the same branch
-                formated_output(bool) : output a formated version string
+                ignore_unknown_tags(bool): skip tags with not decoded versions (default to False)
             Returns:
                 the last version
             """
             VersionStd = cls._getVersionStd(**kwargs)
-
             bAutoVersionStd = False
             if VersionStd == "Auto":
                 bAutoVersionStd = True
-
-            lastTag=cls.MetaVersion.raw
-            cls.__versionReseted = False
-            try:
-                lastTag = gitversionhelper.tag.getLastTag(**kwargs)
-            except gitversionhelper.tag.tagNotFound:
-                logging.warning('tag not found, reseting versionning')
-                cls.__versionReseted = True
-
             bFound = False
             if VersionStd == "SemVer" or (bAutoVersionStd is True) :
                 _r=re.compile(r"^\s*" + cls.VersionStds["SemVer"]["regex"] + r"\s*$",   re.VERBOSE | \
                                                                                         re.IGNORECASE)
-                _m = re.match(_r,lastTag)
+                _m = re.match(_r,tag)
                 if not _m:
                     pass
                 else:
@@ -421,7 +427,7 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
             if VersionStd == "PEP440" or ( (bAutoVersionStd is True)  and (bFound is not True)):
                 _r=re.compile(r"^\s*" + cls.VersionStds["PEP440"]["regex"] + r"\s*$",   re.VERBOSE | \
                                                                                         re.IGNORECASE)
-                _m = re.match(_r,lastTag)
+                _m = re.match(_r,tag)
                 if not _m:
                     pass
                 else:
@@ -437,16 +443,50 @@ class gitversionhelper: # pylint: disable=too-few-public-methods
                     VersionStd = "PEP440"
 
             if not bFound :
-                raise gitversionhelper.version.noValidVersion("no valid version found in tags")
+                raise gitversionhelper.version.noValidVersion("no valid version found in tags")  
+            return cls.MetaVersion(VersionStd, major, minor, patch, pre_count, post_count, tag)
 
-            _v = cls.MetaVersion(VersionStd, major, minor, patch, pre_count, post_count, lastTag)
+        @classmethod
+        def getLastVersion(cls,**kwargs) -> MetaVersion | str : # pylint: disable=R0914, R0912, R0915
+            """get the last version from tags
+            Keyword Arguments:
+                version_std(str): the given version_std (can be None)
+                same_branch(bool): force searching only in the same branch
+                formated_output(bool) : output a formated version string
+                ignore_unknown_tags(bool): skip tags with not decoded versions (default to False)
+            Returns:
+                the last version
+            """
+            lastTag=cls.MetaVersion.raw
+            cls.__versionReseted = False
+            try:
+                lastTag = gitversionhelper.tag.getLastTag(**kwargs)
+            except gitversionhelper.tag.tagNotFound:
+                logging.warning('tag not found, reseting versionning')
+                cls.__versionReseted = True
+
+            _v=None
+            try:
+                _v=cls._parseTag(lastTag,**kwargs)
+            except gitversionhelper.version.noValidVersion:   
+                if ((cls.__OptDict["ignore_unknown_tags"] in kwargs) and (kwargs[cls.__OptDict["ignore_unknown_tags"]] is True)):
+                    tags = gitversionhelper.tag.getTags(sort= "taggerdate",**kwargs)
+                    _v=None
+                    for _tag in tags:
+                        try:
+                            _v=cls._parseTag(_tag,**kwargs)
+                            break;
+                        except:
+                            continue
+                if _v is None:
+                    raise gitversionhelper.version.noValidVersion()  
 
             if ((cls.__OptDict["formated_output"] in kwargs) and (kwargs[cls.__OptDict["formated_output"]] is True)):
                 return _v.doFormatVersion(**kwargs)
             return _v
 
         @classmethod
-        def doFormatVersion(cls,inputversion:MetaVersion,**kwargs):
+        def doFormatVersion(cls,inputversion:MetaVersion,**kwargs) -> str:
             """
             output a formated version string
             Args:

test/test_gitversionhelper.py

@@ -13,8 +13,6 @@ import os
 import pathlib
 import re
 
-from contextlib import redirect_stdout,redirect_stderr
-
 print(__name__)
 print(__package__)
 
@@ -66,129 +64,129 @@ class Test_gitversionhelper(unittest.TestCase):
         _v=self._test_version_readback(tag,**kwargs)
         self._test_version_format(_v,tag,**kwargs)
         
-    def test_nominal_version_auto_1(self):
+    def test_nominal__version__auto_1(self):
         self._test_version_readback_simple("0.0.1")
-    def test_nominal_version_auto_2(self):
+    def test_nominal__version__auto_2(self):
         self._test_version_readback_simple("0.0.2")
-    def test_nominal_version_auto_3(self):
+    def test_nominal__version__auto_3(self):
         self._test_version_readback_simple("0.1.0")
-    def test_nominal_version_auto_4(self):
+    def test_nominal__version__auto_4(self):
         self._test_version_readback_simple("0.1.1")
-    def test_nominal_version_auto_5(self):
+    def test_nominal__version__auto_5(self):
         self._test_version_readback_simple("1.0.0")
-    def test_nominal_version_auto_6(self):
+    def test_nominal__version__auto_6(self):
         self._test_version_readback_simple("1.1.0")
-    def test_nominal_version_auto_7(self):
+    def test_nominal__version__auto_7(self):
         self._test_version_readback_simple("1.2.0")
-    def test_nominal_version_auto_8(self):
+    def test_nominal__version__auto_8(self):
         self._test_version_readback_simple("1.1.1")
-    def test_nominal_version_auto_9(self):
+    def test_nominal__version__auto_9(self):
         self._test_version_readback_simple("1.2.1")
-    def test_nominal_version_auto_PEP440_post(self):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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):
+    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_version_pump_SemVer(self,**kwargs):
+    def test_nominal__version___pump_SemVer(self):
         _v = self._test_version_readback("1.0.0",version_std="SemVer")
         
         _v = _v.bump()
@@ -314,7 +312,7 @@ class Test_gitversionhelper(unittest.TestCase):
         self.assertEqual(_v.post_count, 2)
         self.assertEqual(_v.doFormatVersion(), "2.1.5+post.2")
 
-    def test_version_pump_PEP440(self,**kwargs):
+    def test_nominal__version___pump_PEP440(self):
         _v = self._test_version_readback("1.0.0",version_std="PEP440")
         
         _v = _v.bump()
@@ -440,16 +438,16 @@ class Test_gitversionhelper(unittest.TestCase):
         self.assertEqual(_v.post_count, 2)
         self.assertEqual(_v.doFormatVersion(), "2.1.5.post2")
         
-    def test_nominal_version_SemVer_zeroRev(self):
+    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):
+    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):
+    def test_nominal__version___PEP440_noRev_noTag(self):
         with  open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue")
 
@@ -459,20 +457,13 @@ class Test_gitversionhelper(unittest.TestCase):
         _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="PEP440")
         
         self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
-        self.assertIsInstance(_v.raw, str)
+        self._test_version_format(_v,"0.1.0",version_std="PEP440")
         self.assertEqual(_v.raw, "0.1.0")
-        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.major,0)
         self.assertEqual(_v.minor,1)
         self.assertEqual(_v.patch,0)
-        self._test_version_format(_v,"0.1.0",version_std="PEP440")
         
-    def test_nominal_version_SemVer_noRev_noTag(self):
+    def test_nominal__version___SemVer_noRev_noTag(self):
         with  open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue")
 
@@ -482,20 +473,13 @@ class Test_gitversionhelper(unittest.TestCase):
         _v = pygitversionhelper.gitversionhelper.version.getLastVersion(version_std="SemVer")
         
         self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
-        self.assertIsInstance(_v.raw, str)
+        self._test_version_format(_v,"0.1.0",version_std="SemVer")
         self.assertEqual(_v.raw, "0.1.0")
-        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.major,0)
         self.assertEqual(_v.minor,1)
         self.assertEqual(_v.patch,0)
-        self._test_version_format(_v,"0.1.0",version_std="SemVer")
         
-    def test_nominal_version_AUTO_noRev_noTag(self):
+    def test_nominal__version___AUTO_noRev_noTag(self):
         with  open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue")
 
@@ -505,21 +489,14 @@ class Test_gitversionhelper(unittest.TestCase):
         _v = pygitversionhelper.gitversionhelper.version.getLastVersion()
         
         self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
-        self.assertIsInstance(_v.raw, str)
+        self._test_version_format(_v,"0.1.0")
         self.assertEqual(_v.raw, "0.1.0")
-        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.major,0)
         self.assertEqual(_v.minor,1)
         self.assertEqual(_v.patch,0)
-        self._test_version_format(_v,"0.1.0")
         
         
-    def test_nominal_version_AUTO_bump_commits(self):
+    def test_nominal__version___AUTO_bump_commits(self):
         with  open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue")
         os.system("git add .")
@@ -529,20 +506,13 @@ class Test_gitversionhelper(unittest.TestCase):
         _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
         
         self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
-        self.assertIsInstance(_v.raw, str)
+        self._test_version_format(_v,"0.2.0") 
         self.assertEqual(_v.raw, "0.2.0")
-        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.major,0)
         self.assertEqual(_v.minor,2)
         self.assertEqual(_v.patch,0)
         self.assertEqual(_v.pre_count,0)
-        self.assertEqual(_v.post_count,0)
-        self._test_version_format(_v,"0.2.0")     
+        self.assertEqual(_v.post_count,0)    
         
         with  open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue22")  
@@ -552,20 +522,13 @@ class Test_gitversionhelper(unittest.TestCase):
         _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
         
         self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
-        self.assertIsInstance(_v.raw, str)
+        self._test_version_format(_v,"0.2.1")    
         self.assertEqual(_v.raw, "0.2.1")
-        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.major,0)
         self.assertEqual(_v.minor,2)
         self.assertEqual(_v.patch,1)
         self.assertEqual(_v.pre_count,0)
-        self.assertEqual(_v.post_count,0)
-        self._test_version_format(_v,"0.2.1")     
+        self.assertEqual(_v.post_count,0) 
 
         with  open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue223")  
@@ -580,20 +543,13 @@ class Test_gitversionhelper(unittest.TestCase):
         _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
         
         self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
-        self.assertIsInstance(_v.raw, str)
-        self.assertEqual(_v.raw, "0.2.3")
-        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._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)
-        self._test_version_format(_v,"0.2.3")  
          
         with  open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue225")  
@@ -604,75 +560,48 @@ class Test_gitversionhelper(unittest.TestCase):
         
         self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
         self.assertIsInstance(_v.raw, str)
-        self.assertEqual(_v.raw, "0.2.0+post.4")
-        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._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)
-        self._test_version_format(_v,"0.2.0+post.4")  
         
         _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-patch")
         
         self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
-        self.assertIsInstance(_v.raw, str)
-        self.assertEqual(_v.raw, "0.2.1-pre.4")
-        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._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)
-        self._test_version_format(_v,"0.2.1-pre.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.assertIsInstance(_v.raw, str)
+        self._test_version_format(_v,"0.3.0-pre.4") 
         self.assertEqual(_v.raw, "0.3.0-pre.4")
-        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.major,0)
         self.assertEqual(_v.minor,3)
         self.assertEqual(_v.patch,0)
         self.assertEqual(_v.pre_count,4)
         self.assertEqual(_v.post_count,0)
-        self._test_version_format(_v,"0.3.0-pre.4") 
           
         _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="dev",bump_dev_strategy="pre-major")
         
         self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
-        self.assertIsInstance(_v.raw, str)
-        self.assertEqual(_v.raw, "1.0.0-pre.4")
-        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._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)
-        self._test_version_format(_v,"1.0.0-pre.4")    
         
-    def test_nominal_custom_format(self):
+    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}"))
@@ -687,47 +616,41 @@ class Test_gitversionhelper(unittest.TestCase):
         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_emptyrepo(self):
+    def test_nominal__git__emptyrepo(self):
         _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
         self.assertIsInstance(_v, pygitversionhelper.gitversionhelper.version.MetaVersion)
-        self.assertIsInstance(_v.raw, str)
+        self._test_version_format(_v,"0.1.0")  
         self.assertEqual(_v.raw, "0.1.0")
-        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.major,0)
         self.assertEqual(_v.minor,1)
         self.assertEqual(_v.patch,0)
         self.assertEqual(_v.pre_count,0)
         self.assertEqual(_v.post_count,0)
-        self._test_version_format(_v,"0.1.0")  
         
-    def test_defect_dirty(self):
+    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) as context:
+        with self.assertRaises(pygitversionhelper.gitversionhelper.repository.repositoryDirty) :
             pygitversionhelper.gitversionhelper.version.getCurrentVersion()
 
-    def test_defect_wrongargument_git_sortargs(self):
-        with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) as context:
+    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):
+    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) as context:
+        with self.assertRaises(pygitversionhelper.gitversionhelper.tag.tagNotFound) :
             pygitversionhelper.gitversionhelper.tag.getLastTag()
             
     """ This test is impossible to do
-    def test_defect_git_multipletagsfound(self):
+    def test_defect__git_multipletagsfound(self):
         with  open("demofile.txt", "w+t") as tmpFile:
             tmpFile.write("testvalue")
         os.system("git add .")
@@ -737,19 +660,416 @@ class Test_gitversionhelper(unittest.TestCase):
         with self.assertRaises(pygitversionhelper.gitversionhelper.tag.moreThanOneTag) as context:
             pygitversionhelper.gitversionhelper.tag.getLastTag()
     """
-    
-    def test_defect_wrongargument_bump_type(self):
+
+    def test_defect__wrongargument_bump_type(self):
         _v=self._test_version_readback("0.1.1",version_std="PEP440")
-        with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) as context:
+        with self.assertRaises(pygitversionhelper.gitversionhelper.wrongArguments) :
             pygitversionhelper.gitversionhelper.version.getCurrentVersion(bump_type="toto")
-            
-    def test_defect_wrongargument_bump_dev_strategy(self):
+
+    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) as context:
+        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()
+
+    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 tearDown(self):
         os.chdir("/")
     
@@ -759,16 +1079,9 @@ class Test_gitversionhelperNoRepo(unittest.TestCase):
         self.TmpWorkingDirPath=pathlib.Path(self.TmpWorkingDir.name)
         os.chdir(self.TmpWorkingDirPath)
 
-    def test_defect_norepo(self):
-        with self.assertRaises(pygitversionhelper.gitversionhelper.repository.notAGitRepository) as context:
+    def test_defect__norepo(self):
+        with self.assertRaises(pygitversionhelper.gitversionhelper.repository.notAGitRepository) :
             _v = pygitversionhelper.gitversionhelper.version.getCurrentVersion()
 
     def tearDown(self):
-        os.chdir("/")
-        
-#print(gitversionhelper.tag.getLastTag(same_branch=True))
-#print(gitversionhelper.tag.getDistanceFromLastTag(same_branch=True))
-
-#print(gitversionhelper.version.getLastVersion(same_branch=True,version_std="PEP440"))
-#print(gitversionhelper.version.getLastVersion(same_branch=True,version_std="PEP440"))
-#print(gitversionhelper.version.getLastVersion(same_branch=False,version_std="PEP440"))
+        os.chdir("/")