tests; removed byte array

src/CMakeLists.txt

   DBO/ScCommand.cpp
   include/ScCommand.h
   include/ScCommand.hxx
-  DBO/ScByteArray.cpp
-  include/ScByteArray.h
-  include/ScByteArray.hxx
   DBO/ScBasicCommand.cpp
   include/ScBasicCommand.h
   include/ScBasicCommand.hxx

src/DBO/ScBasicCommand.cpp

 {
 }
 
-ScByteArray ScBasicCommand::getData() const
+const std::string ScBasicCommand::getData() const
 {
     return _data;
 }

src/DBO/ScByteArray.cpp

-//
-// Created by robin on 6/27/15.
-//
-
-#include "ScByteArray.h"
-

src/DBO/ScHex.cpp

 // Created by robin on 6/29/15.
 //
 
-#include <sstream>
+#include <string>
+#include <wintypes.h>
 #include "ScHex.h"
 
 
-char ScHex::hexCharToInt(const char& c)
+const char ScHex::hexCharToInt(const char& c)
 {
     if (c >= 'a')
         return (char)(10 + (c - ('a' - 'A')) - 'A');
     return c - '0';
 }
 
-ScByteArray ScHex::stringToByteArray(const std::string &str)
+const std::string ScHex::stringToByteArray(const std::string &str)
 {
     std::string hexa;
     for (auto c : str)
     {
         data[i / 2] = (hexCharToInt(hexa[i]) << 4) | hexCharToInt(hexa[i + 1]);
     }
-    return ScByteArray(data, hexa.size() / 2);
+    return std::string((char*)data, hexa.size() / 2);
 }
 
-std::string ScHex::byteArrayToString(const ScByteArray &bytes, const std::string &separator)
+const std::string ScHex::byteArrayToString(const std::string &bytes, const std::string &separator)
 {
     std::string res;
-    for (DWORD i = 0; i < bytes.getSize();++i)
+    for (DWORD i = 0; i < bytes.size();++i)
     {
-        res += intToHexChar(bytes.getData()[i]);
-        if (i != bytes.getSize() - 1)
+        res += intToHexChar(bytes.data()[i]);
+        if (i != bytes.size() - 1)
             res += separator;
     }
     return res;
 }
 
-std::string ScHex::intToHexChar(const char &c)
+const std::string ScHex::intToHexChar(const char &c)
 {
     std::string res;
     for (auto c1 : {(c & 0xf0) >> 4, c & 0x0f})

src/DBO/ScResult.cpp

 
 #include "ScResult.h"
 
-ScResult::ScResult(const ScByteArray &data)
+ScResult::ScResult(const std::string &data)
     : _data(data)
 {
 }

src/DataAccess/ScReader.cpp

 
 #include <winscard.h>
 #include <vector>
+#include <string.h>
 #include "ScReader.h"
 
 thread_local LPSCARDCONTEXT ScReader::_context = nullptr;
     _card = new SCARDCONTEXT[1];
     _proto = new DWORD[1];
     auto res = SCardConnect(*_context, _name.c_str(), shareMode, protocols, _card, _proto);
+    if (*_proto == SCARD_PROTOCOL_T0)
+        _sendPci = *SCARD_PCI_T0;
+    if (*_proto == SCARD_PROTOCOL_T1)
+        _sendPci = *SCARD_PCI_T1;
     return res == SCARD_S_SUCCESS;
 }
 
 {
     auto data = command.getData();
     auto resBuffer = new BYTE[size];
-    auto res = SCardTransmit(*_card, _sendPci, data.getData(), data.getSize(), nullptr, resBuffer, &size);
+    auto res = SCardTransmit(*_card, &_sendPci, (BYTE*)data.data(), data.size(), nullptr, resBuffer, &size);
     if (res == SCARD_S_SUCCESS)
-        return std::make_shared<ScResult>(ScByteArray(resBuffer, size));
-    return std::make_shared<ScResult>(ScByteArray());
+        return std::make_shared<ScResult>(std::string((char*)resBuffer, size));
+    return std::make_shared<ScResult>("");
 }
 
 std::vector<std::shared_ptr<ScReader>> ScReader::getReaders()

src/include/ScBasicCommand.h

 
     virtual ~ScBasicCommand();
 
-    virtual ScByteArray getData() const override;
+    virtual const std::string getData() const override;
 
 private:
-    ScByteArray _data;
+    std::string _data;
 };
 
 # include "ScCommand.hxx"

src/include/ScByteArray.h

-//
-// Created by robin on 6/27/15.
-//
-
-#ifndef LIBPCSC_CPPTOOLS_SCBYTEARRAY_H
-# define LIBPCSC_CPPTOOLS_SCBYTEARRAY_H
-
-# include <winscard.h>
-
-class ScByteArray {
-
-public:
-    inline ScByteArray();
-
-    inline ScByteArray(BYTE* const data, const DWORD size);
-
-    inline ScByteArray(const ScByteArray& data);
-
-    inline ~ScByteArray();
-
-    inline DWORD getSize() const;
-
-    inline BYTE* getData() const;
-
-private:
-    DWORD _size;
-
-    BYTE* _data;
-};
-
-# include "ScByteArray.hxx"
-
-#endif //LIBPCSC_CPPTOOLS_SCBYTEARRAY_H

src/include/ScByteArray.hxx

-//
-// Created by robin on 6/27/15.
-//
-
-#include <stdlib.h>
-#include <string.h>
-
-ScByteArray::ScByteArray()
-    : _size(0)
-    , _data(nullptr)
-{
-}
-
-ScByteArray::ScByteArray(BYTE * const data, const DWORD size)
-        : _data(data)
-        , _size(size)
-{
-}
-
-ScByteArray::ScByteArray(const ScByteArray &data)
-{
-    _size = data._size;
-    _data = (BYTE*)memcpy(malloc(_size), data._data, _size);
-}
-
-ScByteArray::~ScByteArray()
-{
-    delete[] _data;
-}
-
-BYTE* ScByteArray::getData() const
-{
-    return _data;
-}
-
-DWORD ScByteArray::getSize() const
-{
-    return _size;
-}

src/include/ScCommand.h

 #ifndef LIBPCSC_CPPTOOLS_SCCOMMAND_H
 # define LIBPCSC_CPPTOOLS_SCCOMMAND_H
 
-# include "ScByteArray.h"
+# include <string>
 
 class ScCommand {
 
 public:
     virtual ~ScCommand();
 
-    virtual ScByteArray getData() const = 0;
+    virtual const std::string getData() const = 0;
 
 };
 

src/include/ScHex.h

 # define PCSC_CPPTOOLS_SCHEX_H
 
 # include <string>
-#include "ScByteArray.h"
 
 class ScHex
 {
 public:
-    static char hexCharToInt(const char& c);
+    static const char hexCharToInt(const char& c);
 
-    static std::string intToHexChar(const char& c);
+    static const std::string intToHexChar(const char& c);
 
-    static std::string byteArrayToString(const ScByteArray& bytes, const std::string& separator = " ");
+    static const std::string byteArrayToString(const std::string& bytes, const std::string& separator = " ");
 
-    static ScByteArray stringToByteArray(const std::string& str);
+    static const std::string stringToByteArray(const std::string& str);
 
 };
 

src/include/ScReader.h

 
     LPDWORD _proto;
 
-    LPSCARD_IO_REQUEST _sendPci;
+    SCARD_IO_REQUEST _sendPci;
 
     LONG _lastResult;
 };

src/include/ScReader.hxx

     : _name(name)
     , _card(nullptr)
     , _proto(nullptr)
-    , _sendPci(nullptr)
     , _lastResult(SCARD_S_SUCCESS)
 {
 }

src/include/ScResult.h

 # define LIBPCSC_CPPTOOLS_SCRESULT_H
 
 
-#include "ScByteArray.h"
+#include <string>
 
 class ScResult
 {
 public:
-    ScResult(const ScByteArray& data);
+    ScResult(const std::string& data);
 
     ~ScResult();
 
+    inline const std::string getData() const;
+
 protected:
-    ScByteArray _data;
+    std::string _data;
 };
 
 # include "ScResult.hxx"

src/include/ScResult.hxx

 // Created by robin on 6/27/15.
 //
 
-
+const std::string ScResult::getData() const
+{
+    return _data;
+}

tests/test_pcsc_cpp_tools.cpp

 #include <gtest/gtest.h>
 #include <ScHex.h>
 #include <ScReader.h>
+#include <ScBasicCommand.h>
 
-#define TEST_Hex(FUNCTION) do {                                                                 \
+#define TEST_Hex(FUNCTION) do {                                                   \
     FUNCTION("", "", 0);                                                          \
     FUNCTION("42", "\x42", 1);                                                    \
     FUNCTION("42 00 FF AA 24", "\x42\x00\xff\xaa\x24", 5);                        \
     } while (0)
 
 #define TEST_byteArrayToString(STR, DATA, SIZE) \
-  EXPECT_EQ(STR, ScHex::byteArrayToString(ScByteArray((BYTE*)memcpy(new BYTE[SIZE], DATA, SIZE), SIZE)))
+  EXPECT_EQ(STR, ScHex::byteArrayToString(std::string((char*)memcpy(new BYTE[SIZE], DATA, SIZE), SIZE)))
 
 TEST(Hex, ByteArrayToString)
 {
 
 #define TEST_stringToByteArray(STR, DATA, SIZE) do {    \
     auto bytes = ScHex::stringToByteArray(STR);         \
-    EXPECT_EQ(SIZE, bytes.getSize());                   \
-    EXPECT_EQ(0, memcmp(bytes.getData(), DATA, SIZE));            \
+    EXPECT_EQ(SIZE, bytes.size());                   \
+    EXPECT_EQ(0, memcmp(bytes.data(), DATA, SIZE));  \
     } while (0)
 
 TEST(Hex, StringToByteArray)
 {
-    TEST_Hex( TEST_stringToByteArray);
+    TEST_Hex(TEST_stringToByteArray);
+}
+
+TEST(Reader, Test1)
+{
+    std::cout << "Ensure that at lest 1 reader is connected";
+    getchar();
+    EXPECT_TRUE(ScReader::establishContext());
+    auto readers = ScReader::getReaders();
+    EXPECT_GE(readers.size(), 1);
+    for (auto reader : readers)
+    {
+        std::cout << reader->getName() << std::endl;
+    }
+    auto reader = readers[0];
+    EXPECT_TRUE(reader->connect());
+    auto res = reader->transmit(ScBasicCommand("94 A4 00 00 02 20 00 00"));
+    EXPECT_NE(nullptr, res->getData().data());
+    auto resp = ScHex::byteArrayToString(res->getData());
+    std::cout << "Response (" << res->getData().size() << "): " << resp << std::endl;
+    EXPECT_TRUE(reader->disconnect());
+    EXPECT_TRUE(ScReader::freeContext());
 }
 
 int main(int argc, char* argv[])