TEST(API, Test2SilenceFp)
{
short zeroes[1024];
std::fill(zeroes, zeroes + 1024, 0);
ChromaprintContext *ctx = chromaprint_new(CHROMAPRINT_ALGORITHM_TEST2);
ASSERT_NE(nullptr, ctx);
SCOPE_EXIT(chromaprint_free(ctx));
ASSERT_EQ(1, chromaprint_start(ctx, 44100, 1));
for (int i = 0; i < 130; i++) {
ASSERT_EQ(1, chromaprint_feed(ctx, zeroes, 1024));
}
char *fp;
uint32_t fp_hash;
ASSERT_EQ(1, chromaprint_finish(ctx));
ASSERT_EQ(1, chromaprint_get_fingerprint(ctx, &fp));
SCOPE_EXIT(chromaprint_dealloc(fp));
ASSERT_EQ(1, chromaprint_get_fingerprint_hash(ctx, &fp_hash));
ASSERT_EQ(18, strlen(fp));
EXPECT_EQ(std::string("AQAAA0mUaEkSRZEGAA"), std::string(fp));
ASSERT_EQ(627964279, fp_hash);
}
std::string OGL4ShaderCompiler::LoadShaderSource(const boost::filesystem::path& path)
{
FILE* file = fopen(path.string().c_str(), "rb");
if(file == nullptr)
{
return "";
}
SCOPE_EXIT(fclose(file));
fseek(file, 0, SEEK_END);
uint64 size = ftell(file);
fseek(file, (long)0, SEEK_SET);
char *szCode = new char[size + 1];
SCOPE_EXIT(delete[] szCode);
fread(szCode, 1, size, file);
szCode[size] = 0;
return szCode;
}
TEST(API, Test2SilenceRawFp)
{
short zeroes[1024];
std::fill(zeroes, zeroes + 1024, 0);
ChromaprintContext *ctx = chromaprint_new(CHROMAPRINT_ALGORITHM_TEST2);
ASSERT_NE(nullptr, ctx);
SCOPE_EXIT(chromaprint_free(ctx));
ASSERT_EQ(1, chromaprint_start(ctx, 44100, 1));
for (int i = 0; i < 130; i++) {
ASSERT_EQ(1, chromaprint_feed(ctx, zeroes, 1024));
}
uint32_t *fp;
int length;
ASSERT_EQ(1, chromaprint_finish(ctx));
ASSERT_EQ(1, chromaprint_get_raw_fingerprint(ctx, &fp, &length));
SCOPE_EXIT(chromaprint_dealloc(fp));
ASSERT_EQ(3, length);
EXPECT_EQ(627964279, fp[0]);
EXPECT_EQ(627964279, fp[1]);
EXPECT_EQ(627964279, fp[2]);
}
int main() {
{
Foo foo;
SCOPE_EXIT(foo.close());
}
return 0;
}
BlockInputStreamPtr LibraryDictionarySource::loadIds(const std::vector<UInt64> & ids)
{
LOG_TRACE(log, "loadIds " << toString() << " size = " << ids.size());
const ClickHouseLibrary::VectorUInt64 ids_data{ext::bit_cast<decltype(ClickHouseLibrary::VectorUInt64::data)>(ids.data()), ids.size()};
auto columns_holder = std::make_unique<ClickHouseLibrary::CString[]>(dict_struct.attributes.size());
ClickHouseLibrary::CStrings columns_pass{static_cast<decltype(ClickHouseLibrary::CStrings::data)>(columns_holder.get()),
dict_struct.attributes.size()};
size_t i = 0;
for (auto & a : dict_struct.attributes)
{
columns_pass.data[i] = a.name.c_str();
++i;
}
void * data_ptr = nullptr;
/// Get function pointer before dataNew call because library->get may throw.
auto func_loadIds
= library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&columns_pass), decltype(&ids_data))>(
"ClickHouseDictionary_v3_loadIds");
data_ptr = library->get<decltype(data_ptr) (*)(decltype(lib_data))>("ClickHouseDictionary_v3_dataNew")(lib_data);
auto data = func_loadIds(data_ptr, &settings->strings, &columns_pass, &ids_data);
auto block = dataToBlock(description.sample_block, data);
SCOPE_EXIT(library->get<void (*)(decltype(lib_data), decltype(data_ptr))>("ClickHouseDictionary_v3_dataDelete")(lib_data, data_ptr));
return std::make_shared<OneBlockInputStream>(block);
}
StoragePtr TableFunctionODBC::executeImpl(const ASTPtr & ast_function, const Context & context) const
{
const ASTFunction & args_func = typeid_cast<const ASTFunction &>(*ast_function);
if (!args_func.arguments)
throw Exception("Table function 'odbc' must have arguments.", ErrorCodes::LOGICAL_ERROR);
ASTs & args = typeid_cast<ASTExpressionList &>(*args_func.arguments).children;
if (args.size() != 2)
throw Exception("Table function 'odbc' requires exactly 2 arguments: ODBC connection string and table name.",
ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH);
for (int i = 0; i < 2; ++i)
args[i] = evaluateConstantExpressionOrIdentifierAsLiteral(args[i], context);
std::string connection_string = static_cast<const ASTLiteral &>(*args[0]).value.safeGet<String>();
std::string table_name = static_cast<const ASTLiteral &>(*args[1]).value.safeGet<String>();
Poco::Data::ODBC::SessionImpl session(connection_string, DBMS_DEFAULT_CONNECT_TIMEOUT_SEC);
SQLHDBC hdbc = session.dbc().handle();
SQLHSTMT hstmt = nullptr;
if (Poco::Data::ODBC::Utility::isError(SQLAllocStmt(hdbc, &hstmt)))
throw Poco::Data::ODBC::ODBCException("Could not allocate connection handle.");
SCOPE_EXIT(SQLFreeStmt(hstmt, SQL_DROP));
/// TODO Why not do SQLColumns instead?
std::string query = "SELECT * FROM " + table_name + " WHERE 1 = 0";
if (Poco::Data::ODBC::Utility::isError(Poco::Data::ODBC::SQLPrepare(hstmt, reinterpret_cast<SQLCHAR *>(&query[0]), query.size())))
throw Poco::Data::ODBC::DescriptorException(session.dbc());
if (Poco::Data::ODBC::Utility::isError(SQLExecute(hstmt)))
throw Poco::Data::ODBC::StatementException(hstmt);
SQLSMALLINT cols = 0;
if (Poco::Data::ODBC::Utility::isError(SQLNumResultCols(hstmt, &cols)))
throw Poco::Data::ODBC::StatementException(hstmt);
/// TODO cols not checked
NamesAndTypesList columns;
for (SQLSMALLINT ncol = 1; ncol <= cols; ++ncol)
{
SQLSMALLINT type = 0;
/// TODO Why 301?
SQLCHAR column_name[301];
/// TODO Result is not checked.
Poco::Data::ODBC::SQLDescribeCol(hstmt, ncol, column_name, sizeof(column_name), NULL, &type, NULL, NULL, NULL);
columns.emplace_back(reinterpret_cast<char *>(column_name), getDataType(type));
}
auto result = StorageODBC::create(table_name, connection_string, "", table_name, ColumnsDescription{columns});
result->startup();
return result;
}
inline bool TestRunner::run(Test* test)
{
SCOPE_EXIT([=]{ delete test; });
TestResult result;
addListeners(result);
RepeatedTest repeated(*test, ROLE(TestOptions).repeat());
result.run(repeated);
return result.isSucc();
}
TEST(API, TestEncodeFingerprintBase64)
{
uint32_t fingerprint[] = { 1, 0 };
char expected[] = "NwAAAkEA";
char *encoded;
int encoded_size;
ASSERT_EQ(1, chromaprint_encode_fingerprint(fingerprint, 2, 55, &encoded, &encoded_size, 1));
SCOPE_EXIT(chromaprint_dealloc(encoded));
ASSERT_EQ(8, encoded_size);
ASSERT_STREQ(expected, encoded);
}
MaterialPtr Compiler::CompileFromStream(Sys_GraphicsPtr pGraphics, DataStream* pStream, const boost::filesystem::path& filename)
{
uint64 size = pStream->Size();
//char* szSrc = new char[size + 1];
char* szSrc = (char*)mem_alloc(size + 1);
szSrc[size] = 0;
//SCOPE_EXIT(delete szSrc);
SCOPE_EXIT(mem_free(szSrc));
pStream->Read(szSrc, size);
return Compile(pGraphics, szSrc, filename);
}
TEST(API, TestEncodeFingerprint)
{
uint32_t fingerprint[] = { 1, 0 };
char expected[] = { 55, 0, 0, 2, 65, 0 };
char *encoded;
int encoded_size;
ASSERT_EQ(1, chromaprint_encode_fingerprint(fingerprint, 2, 55, &encoded, &encoded_size, 0));
SCOPE_EXIT(chromaprint_dealloc(encoded));
ASSERT_EQ(6, encoded_size);
for (int i = 0; i < encoded_size; i++) {
ASSERT_EQ(expected[i], encoded[i]) << "Different at " << i;
}
}
TEST(API, TestDecodeFingerprint)
{
char data[] = { 55, 0, 0, 2, 65, 0 };
uint32_t *fingerprint;
int size;
int algorithm;
ASSERT_EQ(1, chromaprint_decode_fingerprint(data, 6, &fingerprint, &size, &algorithm, 0));
SCOPE_EXIT(chromaprint_dealloc(fingerprint));
ASSERT_EQ(2, size);
ASSERT_EQ(55, algorithm);
ASSERT_EQ(1, fingerprint[0]);
ASSERT_EQ(0, fingerprint[1]);
}
TEST(API, TestFp) {
std::vector<short> data = LoadAudioFile("data/test_stereo_44100.raw");
ChromaprintContext *ctx = chromaprint_new(CHROMAPRINT_ALGORITHM_TEST2);
ASSERT_NE(nullptr, ctx);
SCOPE_EXIT(chromaprint_free(ctx));
ASSERT_EQ(1, chromaprint_get_num_channels(ctx));
ASSERT_EQ(11025, chromaprint_get_sample_rate(ctx));
ASSERT_EQ(1, chromaprint_start(ctx, 44100, 1));
ASSERT_EQ(1, chromaprint_feed(ctx, data.data(), data.size()));
char *fp;
uint32_t fp_hash;
ASSERT_EQ(1, chromaprint_finish(ctx));
ASSERT_EQ(1, chromaprint_get_fingerprint(ctx, &fp));
SCOPE_EXIT(chromaprint_dealloc(fp));
ASSERT_EQ(1, chromaprint_get_fingerprint_hash(ctx, &fp_hash));
EXPECT_EQ(std::string("AQAAC0kkZUqYREkUnFAXHk8uuMZl6EfO4zu-4ABKFGESWIIMEQE"), std::string(fp));
ASSERT_EQ(3732003127, fp_hash);
}
bool Project::Save(const boost::filesystem::path& file)
{
QFile qfile(QString::fromStdString(file.string()));
SCOPE_EXIT(qfile.close());
if (!qfile.open(QIODevice::WriteOnly | QIODevice::Text))
return false;
QXmlStreamWriter writer(&qfile);
writer.setAutoFormatting(true);
writer.setAutoFormattingIndent(-1);
writer.writeStartDocument();
{
writer.writeStartElement("project");
{
writer.writeTextElement("scene", QString::fromStdString(m_pScene->GetFileName().string()));
writer.writeTextElement("clear_color", "0, 0, 0");
writer.writeStartElement("camera");
{
writer.writeTextElement("eye_pos", "0, 0, -100");
writer.writeTextElement("focus_pos", "0, 0, 0");
}
writer.writeEndElement();
}
writer.writeEndElement();
}
writer.writeEndDocument();
m_filePath = file;
RestoreProjectRoot();
return true;
}
bool Project::Open(const boost::filesystem::path& file)
{
QFile qfile(QString::fromStdString(file.string()));
SCOPE_EXIT(qfile.close());
if (!qfile.open(QIODevice::ReadOnly | QIODevice::Text))
return false;
m_filePath = file;
RestoreProjectRoot();
QDomDocument doc;
if(doc.setContent(&qfile) == false)
{
return false;
}
QDomNodeList s = doc.elementsByTagName("scene");
if(s.count() == 0)
{
return false;
}
QString text = s.at(0).toElement().text();
m_pScene = alloc_shared<GameScene>(m_pEngine);
if(text == "")
{
if(false == m_pScene->New())
{
return false;
}
}
else
{
if(false == m_pScene->Load(text.toStdString()))
{
return false;
}
}
s = doc.elementsByTagName("camera");
if(s.count() == 0)
{
return false;
}
QDomElement e = s.at(0).toElement();
QDomElement eye = e.firstChildElement("eye_pos");
QDomElement focus = e.firstChildElement("focus_pos");
if(eye.isNull() == false)
{
math::Vector3 ep;
QString t = eye.text();
QString tmp;
QTextStream stream(&t);
stream >> ep.x >> tmp >> ep.y >> tmp >> ep.z ;
//m_pRenderer->GetCamera()->SetEyePos(ep);
}
BlockInputStreamPtr LibraryDictionarySource::loadKeys(const Columns & key_columns, const std::vector<std::size_t> & requested_rows)
{
LOG_TRACE(log, "loadKeys " << toString() << " size = " << requested_rows.size());
auto holder = std::make_unique<ClickHouseLibrary::Row[]>(key_columns.size());
std::vector<std::unique_ptr<ClickHouseLibrary::Field[]>> column_data_holders;
for (size_t i = 0; i < key_columns.size(); ++i)
{
auto cell_holder = std::make_unique<ClickHouseLibrary::Field[]>(requested_rows.size());
for (size_t j = 0; j < requested_rows.size(); ++j)
{
auto data_ref = key_columns[i]->getDataAt(requested_rows[j]);
cell_holder[j] = ClickHouseLibrary::Field{.data = static_cast<const void *>(data_ref.data), .size = data_ref.size};
}
holder[i]
= ClickHouseLibrary::Row{.data = static_cast<ClickHouseLibrary::Field *>(cell_holder.get()), .size = requested_rows.size()};
column_data_holders.push_back(std::move(cell_holder));
}
ClickHouseLibrary::Table request_cols{.data = static_cast<ClickHouseLibrary::Row *>(holder.get()), .size = key_columns.size()};
void * data_ptr = nullptr;
/// Get function pointer before dataNew call because library->get may throw.
auto func_loadKeys = library->get<void * (*)(decltype(data_ptr), decltype(&settings->strings), decltype(&request_cols))>(
"ClickHouseDictionary_v3_loadKeys");
data_ptr = library->get<decltype(data_ptr) (*)(decltype(lib_data))>("ClickHouseDictionary_v3_dataNew")(lib_data);
auto data = func_loadKeys(data_ptr, &settings->strings, &request_cols);
auto block = dataToBlock(description.sample_block, data);
SCOPE_EXIT(library->get<void (*)(decltype(lib_data), decltype(data_ptr))>("ClickHouseDictionary_v3_dataDelete")(lib_data, data_ptr));
return std::make_shared<OneBlockInputStream>(block);
}
bool LibraryDictionarySource::isModified() const
{
if (auto func_isModified
= library->tryGet<bool (*)(decltype(lib_data), decltype(&settings->strings))>("ClickHouseDictionary_v3_isModified"))
return func_isModified(lib_data, &settings->strings);
return true;
}
bool LibraryDictionarySource::supportsSelectiveLoad() const
{
if (auto func_supportsSelectiveLoad
= library->tryGet<bool (*)(decltype(lib_data), decltype(&settings->strings))>("ClickHouseDictionary_v3_supportsSelectiveLoad"))
return func_supportsSelectiveLoad(lib_data, &settings->strings);
return true;
}
DictionarySourcePtr LibraryDictionarySource::clone() const
{
return std::make_unique<LibraryDictionarySource>(*this);
}
std::string LibraryDictionarySource::toString() const
{
return path;
}
void registerDictionarySourceLibrary(DictionarySourceFactory & factory)
{
auto createTableSource = [=](const DictionaryStructure & dict_struct,
const Poco::Util::AbstractConfiguration & config,
const std::string & config_prefix,
Block & sample_block,
const Context &) -> DictionarySourcePtr
{
return std::make_unique<LibraryDictionarySource>(dict_struct, config, config_prefix + ".library", sample_block);
};
factory.registerSource("library", createTableSource);
}
}
