SYNERGY1-1511 Refactoring for v3 licenses (#7183)

* SYNERGY1-1511 Refactor SerialKey constructor

* SYNERGY1-1511 Refactor SerialKey::parse

* SYNERGY1-1511 Remove unused includes

* SYNERGY1-1511 Remove key generation

* SYNERGY1-1511 Remove "using namespace std;"

* SYNERGY1-1511 Add struct SerialKeyData

* SYNERGY1-1511 Replace member with the new DTO

* SYNERGY1-1511 Rename members

* SYNERGY1-1511 Add a new class SerialKeyParser

* SYNERGY1-1511 Use SerialKeyParser

* Add SerialKeyParserV3

* Add setters and remove unused fields

* Fix return type

* Add comments

* Fix compilation

* Fix code smels

* Update ChangeLog

ChangeLog

@@ -1,5 +1,8 @@
 v1.14.5-snapshot
 ===========
+Enhancements:
+- #7183 Refactoring for v3 licenses
+
 Bug fixes:
 - #7182 Remove unused TLS options from the GUI on Synergy Client
 ===========

src/lib/shared/SerialKey.cpp

@@ -17,39 +17,26 @@
 
 #include "SerialKey.h"
 
-#include <fstream>
-#include <iostream>
-#include <algorithm>
 #include <vector>
-#include <climits>
-#include <sstream>
-#include <iomanip>
 #include <stdexcept>
+#include <climits>
 #include "SerialKeyEdition.h"
-
+#include "SerialKeyParser.h"
-using namespace std;
-static std::string hexEncode (std::string const& str);
 
 SerialKey::SerialKey(Edition edition):
-    m_userLimit(1),
+    m_data(edition)
-    m_warnTime(ULLONG_MAX),
-    m_expireTime(ULLONG_MAX),
-    m_edition(edition)
 {
 }
 
-SerialKey::SerialKey(std::string serial) :
+SerialKey::SerialKey(const std::string& serial) :
-    m_userLimit(1),
+    m_data(serial)
-    m_warnTime(0),
-    m_expireTime(0),
-    m_edition(kBasic)
 {
-    string plainText = decode(serial);
+    SerialKeyParser parser;
-    bool valid = false;
+
-    if (!plainText.empty()) {
+    if (parser.parse(serial)) {
-        valid = parse(plainText);
+        m_data = parser.getData();
     }
-    if (!valid) {
+    else {
         throw std::runtime_error ("Invalid serial key");
     }
 }
@@ -61,7 +48,7 @@ SerialKey::isExpiring(time_t currentTime) const
 
     if (isTemporary()) {
         unsigned long long currentTimeAsLL = static_cast<unsigned long long>(currentTime);
-        if ((m_warnTime <= currentTimeAsLL) && (currentTimeAsLL < m_expireTime)) {
+        if ((m_data.warnTime <= currentTimeAsLL) && (currentTimeAsLL < m_data.expireTime)) {
             result = true;
         }
     }
@@ -76,7 +63,7 @@ SerialKey::isExpired(time_t currentTime) const
 
     if (isTemporary()) {
         unsigned long long currentTimeAsLL = static_cast<unsigned long long>(currentTime);
-        if (m_expireTime <= currentTimeAsLL) {
+        if (m_data.expireTime <= currentTimeAsLL) {
             result = true;
         }
     }
@@ -87,13 +74,13 @@ SerialKey::isExpired(time_t currentTime) const
 bool
 SerialKey::isTrial() const
 {
-    return m_KeyType.isTrial();
+    return m_data.keyType.isTrial();
 }
 
 bool
 SerialKey::isTemporary() const
 {
-    return m_KeyType.isTemporary();
+    return m_data.keyType.isTemporary();
 }
 
 bool
@@ -101,7 +88,7 @@ SerialKey::isValid() const
 {
     bool Valid = true;
 
-    if (!m_edition.isValid() || isExpired(::time(0)))
+    if (!m_data.edition.isValid() || isExpired(::time(nullptr)))
     {
         Valid = false;
     }
@@ -112,46 +99,13 @@ SerialKey::isValid() const
 Edition
 SerialKey::edition() const
 {
-    return m_edition.getType();
+    return m_data.edition.getType();
 }
 
-static std::string
+const std::string&
-hexEncode (std::string const& str) {
-    std::ostringstream oss;
-    for (size_t i = 0; i < str.size(); ++i) {
-        unsigned c = str[i];
-        c %= 256;
-        oss << std::setfill('0') << std::hex << std::setw(2)
-            << std::uppercase;
-        oss << c;
-    }
-    return oss.str();
-}
-
-std::string
 SerialKey::toString() const
 {
-    std::ostringstream oss;
+    return m_data.key;
-    oss << "{";
-    if (isTemporary()) {
-        if (isTrial()){
-            oss << "v2;" << SerialKeyType::TRIAL << ";";
-        }
-        else{
-            oss << "v2;" << SerialKeyType::SUBSCRIPTION << ";";
-        }
-    } else {
-        oss << "v1;";
-    }
-    oss << m_edition.getName() << ";";
-    oss << m_name << ";";
-    oss << m_userLimit << ";";
-    oss << m_email << ";";
-    oss << m_company << ";";
-    oss << (isTemporary() ? m_warnTime : 0) << ";";
-    oss << (isTemporary() ? m_expireTime : 0);
-    oss << "}";
-    return hexEncode(oss.str());
 }
 
 time_t
@@ -161,8 +115,8 @@ SerialKey::daysLeft(time_t currentTime) const
     unsigned long long const day = 60 * 60 * 24;
 
     unsigned long long currentTimeAsLL = static_cast<unsigned long long>(currentTime);
-    if (currentTimeAsLL < m_expireTime) {
+    if (currentTimeAsLL < m_data.expireTime) {
-        timeLeft = m_expireTime - currentTimeAsLL;
+        timeLeft = m_data.expireTime - currentTimeAsLL;
     }
 
     unsigned long long daysLeft = 0;
@@ -177,7 +131,7 @@ SerialKey::getSpanLeft(time_t time) const
     int result{-1};
 
     if (isTemporary() && !isExpired(time)){
-        auto timeLeft = (m_expireTime - time) * 1000;
+        auto timeLeft = (m_data.expireTime - time) * 1000;
 
         if (timeLeft < INT_MAX){
             result = static_cast<int>(timeLeft);
@@ -189,95 +143,3 @@ SerialKey::getSpanLeft(time_t time) const
 
     return result;
 }
-
-std::string
-SerialKey::email() const
-{
-    return m_email;
-}
-
-std::string
-SerialKey::decode(const std::string& serial)
-{
-    static const char* const lut = "0123456789ABCDEF";
-    string output;
-    size_t len = serial.length();
-    if (len & 1) {
-        return output;
-    }
-
-    output.reserve(len / 2);
-    for (size_t i = 0; i < len; i += 2) {
-
-        char a = serial[i];
-        char b = serial[i + 1];
-
-        const char* p = std::lower_bound(lut, lut + 16, a);
-        const char* q = std::lower_bound(lut, lut + 16, b);
-
-        if (*q != b || *p != a) {
-            return output;
-        }
-
-        output.push_back(static_cast<char>(((p - lut) << 4) | (q - lut)));
-    }
-
-    return output;
-}
-
-bool
-SerialKey::parse(std::string plainSerial)
-{
-    string parityStart = plainSerial.substr(0, 1);
-    string parityEnd = plainSerial.substr(plainSerial.length() - 1, 1);
-
-    bool valid = false;
-
-    // check for parity chars { and }, record parity result, then remove them.
-    if (parityStart == "{" && parityEnd == "}") {
-        plainSerial = plainSerial.substr(1, plainSerial.length() - 2);
-
-        // tokenize serialised subscription.
-        vector<string> parts;
-        std::string::size_type pos = 0;
-        bool look = true;
-        while (look) {
-            std::string::size_type start = pos;
-            pos = plainSerial.find(";", pos);
-            if (pos == string::npos) {
-                pos = plainSerial.length();
-                look = false;
-            }
-            parts.push_back(plainSerial.substr(start, pos - start));
-            pos += 1;
-        }
-
-        if ((parts.size() == 8)
-                && (parts.at(0).find("v1") != string::npos)) {
-            // e.g.: {v1;basic;Bob;1;email;company name;1398297600;1398384000}
-            m_edition.setType(parts.at(1));
-            m_name = parts.at(2);
-            sscanf(parts.at(3).c_str(), "%d", &m_userLimit);
-            m_email = parts.at(4);
-            m_company = parts.at(5);
-            sscanf(parts.at(6).c_str(), "%lld", &m_warnTime);
-            sscanf(parts.at(7).c_str(), "%lld", &m_expireTime);
-            valid = true;
-        }
-        else if ((parts.size() == 9)
-                 && (parts.at(0).find("v2") != string::npos)) {
-            // e.g.: {v2;trial;basic;Bob;1;email;company name;1398297600;1398384000}
-            m_KeyType.setKeyType(parts.at(1));
-            m_edition.setType(parts.at(2));
-            m_name = parts.at(3);
-            sscanf(parts.at(4).c_str(), "%d", &m_userLimit);
-            m_email = parts.at(5);
-            m_company = parts.at(6);
-            sscanf(parts.at(7).c_str(), "%lld", &m_warnTime);
-            sscanf(parts.at(8).c_str(), "%lld", &m_expireTime);
-            valid = true;
-        }
-    }
-
-    return valid;
-}

src/lib/shared/SerialKey.h

@@ -19,19 +19,14 @@
 
 #include <string>
 #include <ctime>
-#include "EditionType.h"
+#include "SerialKeyData.h"
-#include "SerialKeyType.h"
 #include "SerialKeyEdition.h"
 
-#ifdef TEST_ENV
-#include <gtest/gtest_prod.h>
-#endif
-
 class SerialKey {
     friend bool operator== (SerialKey const&, SerialKey const&);
 public:
     explicit SerialKey(Edition edition = kUnregistered);
-    explicit SerialKey(std::string serial);
+    explicit SerialKey(const std::string& serial);
 
     bool                isExpiring(time_t currentTime) const;
     bool                isExpired(time_t currentTime) const;
@@ -40,45 +35,18 @@ public:
     bool                isValid() const;
     time_t              daysLeft(time_t currentTime) const;
     int                 getSpanLeft(time_t time = ::time(0)) const;
-    std::string         email() const;
     Edition             edition() const;
-    std::string         toString() const;
+    const std::string&  toString() const;
-
-    static std::string  decode(const std::string& serial);
 
 private:
-    bool                parse(std::string plainSerial);
+    SerialKeyData         m_data;
 
-#ifdef TEST_ENV
-private:
-    FRIEND_TEST(SerialKeyTests, parse_noParty_invalid);
-    FRIEND_TEST(SerialKeyTests, parse_invalidPartsLenghth_invalid);
-    FRIEND_TEST(SerialKeyTests, parse_validV1Serial_valid);
-    FRIEND_TEST(SerialKeyTests, parse_validV2Serial_valid);
-#endif
-
-private:
-    std::string           m_name;
-    std::string           m_email;
-    std::string           m_company;
-    unsigned              m_userLimit;
-    unsigned long long    m_warnTime;
-    unsigned long long    m_expireTime;
-    SerialKeyEdition      m_edition;
-    SerialKeyType         m_KeyType;
 };
 
 
 inline bool
 operator== (SerialKey const& lhs, SerialKey const& rhs) {
-    return (lhs.m_name == rhs.m_name) &&
+    return (lhs.m_data == rhs.m_data);
-            (lhs.m_email == rhs.m_email) &&
-            (lhs.m_company == rhs.m_company) &&
-            (lhs.m_userLimit == rhs.m_userLimit) &&
-            (lhs.m_warnTime == rhs.m_warnTime) &&
-            (lhs.m_expireTime == rhs.m_expireTime) &&
-            (lhs.m_edition == rhs.m_edition) &&
-            (lhs.m_KeyType == rhs.m_KeyType);
 }
 
 inline bool

src/lib/shared/SerialKeyData.h

@@ -0,0 +1,60 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2022 Symless Ltd.
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <string>
+#include "SerialKeyType.h"
+#include "SerialKeyEdition.h"
+
+/**
+ * @brief The SerialKeyData struct
+ * This is DTO which stores key data
+ */
+struct SerialKeyData {
+    std::string           key;            // Encoded serial key as a string
+    SerialKeyEdition      edition;        // Serial key edition
+    SerialKeyType         keyType;        // Serial key type
+    unsigned long long    warnTime   = 0; // Warning time
+    unsigned long long    expireTime = 0; // Expiration time
+
+    /**
+     * @brief SerialKeyData constructor
+     * @param key encoded key
+     */
+    explicit SerialKeyData(const std::string& key) :
+        key(key)
+    {
+    }
+
+    /**
+     * @brief SerialKeyData default constructor
+     * @param key edition. Unregistered by default
+     */
+    explicit SerialKeyData(Edition edition = kUnregistered) :
+        edition(edition)
+    {
+    }
+};
+
+inline bool
+operator== (SerialKeyData const& lhs, SerialKeyData const& rhs) {
+    return  (lhs.key == rhs.key) &&
+            (lhs.warnTime == rhs.warnTime) &&
+            (lhs.expireTime == rhs.expireTime) &&
+            (lhs.edition == rhs.edition) &&
+            (lhs.keyType == rhs.keyType);
+}

src/lib/shared/SerialKeyParser.cpp

@@ -0,0 +1,155 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2022 Symless Ltd.
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "SerialKeyParser.h"
+
+void
+SerialKeyParser::setKey(const std::string& key)
+{
+    m_data.key = key;
+}
+
+void
+SerialKeyParser::setType(const std::string& type)
+{
+    m_data.keyType.setKeyType(type);
+}
+
+void
+SerialKeyParser::setEdition(const std::string& edition)
+{
+    m_data.edition.setType(edition);
+}
+
+void
+SerialKeyParser::setWarningTime(const std::string& warnTime)
+{
+    sscanf(warnTime.c_str(), "%lld", &m_data.warnTime);
+}
+
+void
+SerialKeyParser::setExpirationTime(const std::string& expTime)
+{
+    sscanf(expTime.c_str(), "%lld", &m_data.expireTime);
+}
+
+std::string
+SerialKeyParser::decode(const std::string& serial) const
+{
+    static const char* const lut = "0123456789ABCDEF";
+    std::string output;
+    size_t len = serial.length();
+    if (len & 1) {
+        return output;
+    }
+
+    output.reserve(len / 2);
+    for (size_t i = 0; i < len; i += 2) {
+
+        char a = serial[i];
+        char b = serial[i + 1];
+
+        const auto p = std::lower_bound(lut, lut + 16, a);
+        const auto q = std::lower_bound(lut, lut + 16, b);
+
+        if (*q != b || *p != a) {
+            return output;
+        }
+
+        output.push_back(static_cast<char>(((p - lut) << 4) | (q - lut)));
+    }
+
+    return output;
+}
+
+bool
+SerialKeyParser::parse(const std::string& plainSerial)
+{
+    bool valid = false;
+    auto key = decode(plainSerial);
+    const auto parts = splitToParts(key);
+
+    if ((parts.size() == 8) && (parts.at(0).find("v1") != std::string::npos)) {
+        setKey(plainSerial);
+        parseV1(parts);
+        valid = true;
+    }
+    else if ((parts.size() == 9) && (parts.at(0).find("v2") != std::string::npos)) {
+        setKey(plainSerial);
+        parseV2(parts);
+        valid = true;
+    }
+
+    return valid;
+}
+
+const SerialKeyData&
+SerialKeyParser::getData() const
+{
+    return m_data;
+}
+
+void
+SerialKeyParser::parseV1(const std::vector<std::string>& parts)
+{
+    // e.g.: {v1;basic;Bob;1;email;company name;1398297600;1398384000}
+    setEdition(parts.at(1));
+    setWarningTime(parts.at(6));
+    setExpirationTime(parts.at(7));
+}
+
+void
+SerialKeyParser::parseV2(const std::vector<std::string>& parts)
+{
+    // e.g.: {v2;trial;basic;Bob;1;email;company name;1398297600;1398384000}
+    setType(parts.at(1));
+    setEdition(parts.at(2));
+    setWarningTime(parts.at(7));
+    setExpirationTime(parts.at(8));
+}
+
+std::vector<std::string>
+SerialKeyParser::splitToParts(const std::string& plainSerial) const
+{
+    // tokenize serialised subscription.
+    std::vector<std::string> parts;
+
+    if (!plainSerial.empty()) {
+        std::string parityStart = plainSerial.substr(0, 1);
+        std::string parityEnd = plainSerial.substr(plainSerial.length() - 1, 1);
+
+        // check for parity chars { and }, record parity result, then remove them.
+        if (parityStart == "{" && parityEnd == "}") {
+            const auto serialData = plainSerial.substr(1, plainSerial.length() - 2);
+
+            std::string::size_type pos = 0;
+            bool look = true;
+            while (look) {
+                std::string::size_type start = pos;
+                pos = serialData.find(";", pos);
+                if (pos == std::string::npos) {
+                    pos = serialData.length();
+                    look = false;
+                }
+                parts.push_back(serialData.substr(start, pos - start));
+                pos += 1;
+            }
+        }
+    }
+
+    return parts;
+}

src/lib/shared/SerialKeyParser.h

@@ -0,0 +1,101 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2022 Symless Ltd.
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include <string>
+#include <vector>
+#include "SerialKeyData.h"
+
+class SerialKeyParser
+{
+public:
+    /**
+     * @brief ~SerialKeyParser destructor
+     */
+    virtual ~SerialKeyParser(){}
+    /**
+     * @brief parse serial key
+     * @param plainSerial encoded serial key
+     * @return true if parsed
+     */
+    virtual bool parse(const std::string& plainSerial);
+
+    /**
+     * @brief getData getter for serial key data
+     * @return serial key data as DTO
+     */
+    const SerialKeyData& getData() const;
+
+    /**
+     * @brief setKey setter to set encoded key
+     * @param key encoded serial key
+     */
+    void setKey(const std::string& key);
+
+    /**
+     * @brief setType setter for serial type
+     * @param type serial key type
+     */
+    void setType(const std::string& type);
+
+    /**
+     * @brief setEdition setter for serial edition
+     * @param edition serial key edition
+     */
+    void setEdition(const std::string& edition);
+
+    /**
+     * @brief setWarningTime setter for warning time
+     * @param warnTime warning time for key as a string
+     */
+    void setWarningTime(const std::string& warnTime);
+
+    /**
+     * @brief setExpirationTime setter for expiration date
+     * @param expTime expiration data as a string
+     */
+    void setExpirationTime(const std::string& expTime);
+
+private:
+    /**
+     * @brief decode serial key from encoded string
+     * @param encoded serial key as a string
+     * @return decoded serial key as a string
+     */
+    std::string decode(const std::string& serial) const;
+
+    /**
+     * @brief parseV1 parse serial key version 1
+     * @param parts of serial key version 1
+     */
+    void parseV1(const std::vector<std::string>& parts);
+
+    /**
+     * @brief parseV2 parse serial key version 2
+     * @param parts parts of serial key version 2
+     */
+    void parseV2(const std::vector<std::string>& parts);
+
+    /**
+     * @brief splitToParts splits decoded serial key to parts
+     * @param plainSerial decoded serial key as a string
+     * @return splitted serial key
+     */
+    std::vector<std::string> splitToParts(const std::string& plainSerial) const;
+
+    SerialKeyData m_data{}; //serial key data
+};

src/lib/shared/SerialKeyParserV3.cpp

@@ -0,0 +1,8 @@
+#include "SerialKeyParserV3.h"
+
+bool
+SerialKeyParserV3::parse(const std::string& plainSerial)
+{
+    setKey(plainSerial);
+    return true;
+}

src/lib/shared/SerialKeyParserV3.h

@@ -0,0 +1,30 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2022 Symless Ltd.
+ *
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file LICENSE that should have accompanied this file.
+ *
+ * This package is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+#pragma once
+
+#include "SerialKeyParser.h"
+
+class SerialKeyParserV3 : public SerialKeyParser
+{
+public:
+    /**
+     * @brief parse serial key
+     * @param plainSerial encoded serial key
+     * @return true if parsed
+     */
+    bool parse(const std::string& plainSerial) override;
+};

src/test/unittests/shared/SerialKeyTests.cpp

@@ -22,62 +22,6 @@
 
 #include "test/global/gtest.h"
 
-TEST(SerialKeyTests, decode_empty_returnEmptyString)
-{
-    std::string plainText = SerialKey::decode("");
-    EXPECT_EQ(0, plainText.size());
-}
-
-TEST(SerialKeyTests, decode_invalidDigit_returnEmptyString)
-{
-    std::string plainText = SerialKey::decode("MOCKZ");
-    EXPECT_EQ(0, plainText.size());
-}
-
-TEST(SerialKeyTests, decode_validSerial_returnPlainText)
-{
-    std::string plainText = SerialKey::decode("53796E6572677920726F636B7321");
-    EXPECT_EQ("Synergy rocks!", plainText);
-}
-
-TEST(SerialKeyTests, parse_noParty_invalid)
-{
-    SerialKey serial;
-    bool r = serial.parse("MOCK");
-    EXPECT_FALSE(r);
-}
-
-TEST(SerialKeyTests, parse_invalidPartsLenghth_invalid)
-{
-    SerialKey serial;
-    bool r = serial.parse("{Synergy;Rocks}");
-    EXPECT_FALSE(r);
-}
-
-TEST(SerialKeyTests, parse_validV1Serial_valid)
-{
-    SerialKey serial;
-    bool r = serial.parse("{v1;basic;Bob;1;email;company name;0;86400}");
-    EXPECT_EQ(true, r);
-    EXPECT_EQ(kBasic, serial.edition());
-    EXPECT_FALSE(serial.isExpired(0));
-    EXPECT_EQ(true, serial.daysLeft(0));
-    EXPECT_FALSE(serial.isExpiring(1));
-}
-
-TEST(SerialKeyTests, parse_validV2Serial_valid)
-{
-    SerialKey serial;
-    bool r = serial.parse("{v2;trial;pro;Bob;1;email;company name;0;86400}");
-    EXPECT_EQ(true, r);
-    EXPECT_EQ(kPro, serial.edition());
-    EXPECT_FALSE(serial.isExpired(0));
-    EXPECT_EQ(true, serial.daysLeft(0));
-    EXPECT_EQ(true, serial.isExpiring(1));
-    EXPECT_EQ(true, serial.isTrial());
-    EXPECT_EQ(true, serial.isTemporary());
-}
-
 TEST(SerialKeyTests, isExpiring_validV2TrialBasicSerial_returnFalse)
 {
     // {v2;trial;basic;Bob;1;email;company name;1;86400}