TEST_F(SHAPE, Coordinates)
{
std::vector<ade::DimT> slist = {9, 3, 7, 8, 5};
ade::Shape shape(slist);
ade::CoordT coord;
for (ade::NElemT i = 0, n = shape.n_elems(); i < n; ++i)
{
coord = ade::coordinate(shape, i);
for (uint8_t i = 0; i < ade::rank_cap; ++i)
{
EXPECT_GT(shape.at(i), coord[i]);
}
ade::NElemT idx = ade::index(shape, coord);
EXPECT_EQ(i, idx);
}
for (uint8_t i = 0; i < ade::rank_cap; ++i)
{
coord[i] = shape.at(i);
}
std::string shapestr = shape.to_string();
std::string fatalmsg = fmts::sprintf("cannot get index of bad coordinate "
"%s for shape %s", shapestr.c_str(), shapestr.c_str());
EXPECT_FATAL(ade::index(shape, coord), fatalmsg.c_str());
std::string fatalmsg2 = fmts::sprintf("cannot get coordinate of index %d "
"(>= shape %s)", shape.n_elems(), shapestr.c_str());
EXPECT_FATAL(ade::coordinate(shape, shape.n_elems()), fatalmsg2.c_str());
}
bool slice_file_extension(slice path, slice *left, slice *right)
{
EXPECT_FATAL(path.start && path.end);
EXPECT_FATAL(left);
EXPECT_FATAL(right);
// ensure paths containing "." but no extension, such as "./test",
// are avoided.
// side-effect: ensures "/" never appears inside an extension
// e.g. "myfile.txt/2"
const char *rslash = slice_strrchr(path, '/');
const char *rdot = slice_strrchr(path, '.');
if (rslash && rdot)
{
if (rslash > rdot) { return false; }
}
// ensure "dotfiles", i.e. hidden files on linux like ".example", are
// treated as named rather than as empty names with extensions
if (rdot)
{
// starts with ".", no folders
if ((!rslash) && (rdot == path.start)) { return false; }
// filename part starts with ".", its a hidden dotfile
if ((rslash) && ((rslash + 1) == rdot)) { return false; }
}
if (!slice_on_charr(path, '.', left, right)) { return false; }
// avoid empty extensions e.g. "file."
if (!slice_len(*right)) { return false; }
return true;
}
static bool filelike_FILE_size(filelike *f, size_t *dest)
{
FILE *src = (void *) f->ptr;
if (0 != fseek(src, 0, SEEK_END))
{
ERRORf("%s", "Seek to end error");
return false;
}
long sz = ftell(src);
EXPECT_FATAL(sz >= 0);
// don't support files >= 2GB because the cross-platform pain isn't worth it
if (sz > INT_MAX) { return false; }
if (f->window_start >= 0)
{
ssize_t size = (ssize_t) sz;
ssize_t window_size = f->window_end - f->window_start;
size -= window_size;
if (size < 0) { return false; }
*dest = (size_t) size;
}
else
{
*dest = (size_t) sz;
}
return true;
}
static bool slice_on_fnp(
// function to find char to split on
const char *(*fn)(const char *, int, size_t),
slice src, const char c, slice *left, slice *right)
{
EXPECT_FATAL(src.start && src.end);
EXPECT_FATAL(left);
EXPECT_FATAL(right);
size_t len = slice_len(src);
const char *index = fn(src.start, c, len);
if (!index) { return false; }
*left = (slice){src.start, index};
*right = (slice){index + 1, src.end};
return true;
}
TEST_F(SHAPE, Init)
{
ade::Shape scalar;
std::vector<ade::DimT> slist = {12, 43, 56};
ade::Shape vec(slist);
uint8_t n = slist.size();
std::vector<ade::DimT> longlist = {4, 23, 44, 52, 19, 92, 12, 2, 5};
ade::Shape lvec(longlist);
std::vector<ade::DimT> zerolist = {43, 2, 5, 33, 0, 2, 7};
std::string fatalmsg = "cannot create shape with vector containing zero: " +
fmts::to_string(zerolist.begin(), zerolist.end());
EXPECT_FATAL(ade::Shape junk(zerolist), fatalmsg.c_str());
for (uint8_t i = 0; i < ade::rank_cap; ++i)
{
EXPECT_EQ(1, scalar.at(i));
}
for (uint8_t i = 0; i < n; ++i)
{
EXPECT_EQ(slist[i], vec.at(i));
}
for (uint8_t i = n; i < ade::rank_cap; ++i)
{
EXPECT_EQ(1, vec.at(i));
}
for (uint8_t i = 0; i < ade::rank_cap; ++i)
{
EXPECT_EQ(longlist[i], lvec.at(i));
}
EXPECT_FATAL(scalar.at(ade::rank_cap), "cannot access out of bounds index 8");
EXPECT_FATAL(vec.at(ade::rank_cap), "cannot access out of bounds index 8");
}
void filelike_range_from_FILE(filelike *f, FILE *o, ssize_t window_start, ssize_t window_end)
{
char buf[CFW_MAX_PATH]; UNUSED(buf);
TRACEf("io", "filelike=%p, FILE=%p <%s>, window_start="PRINTF_ZD ", window_end="PRINTF_ZD ,
(void *) f, (void *) o, FILE_name(o, buf), CAST_ZD(window_start), CAST_ZD(window_end));
EXPECT_FATAL(f);
EXPECT_FATAL(o);
EXPECT_FATAL(window_start <= window_end);
f->ptr = (void *) o;
f->impl = &filelike_impl_FILE;
f->window_start = window_start;
f->window_end = window_end;
if ((f->window_start >= 0) && (0 != fseek(o, (long) f->window_start, SEEK_SET)))
{
DIE("Seek to start error");
}
TRACEOUT("io");
}
TEST(DATA, MismatchSize)
{
std::vector<ade::DimT> slist = {4, 2, 3};
ade::Shape shape(slist);
std::vector<double> data = {
41, 29, 86, 43, 12, 55, 68, 87, 16, 92, 26, 28,
13, 1, 62, 9, 27, 10, 23, 70, 80, 67, 96, 22, 24
};
std::stringstream ss;
ss << "cannot create variable with data size " << data.size() <<
" against shape " << shape.to_string();
EXPECT_FATAL(llo::Variable<double>::get(data, shape), ss.str().c_str());
}
bool slice_uri_scheme(slice uri, slice *left, slice *right)
{
EXPECT_FATAL(uri.start && uri.end);
if (!slice_len(uri))
{
return false; // empty string
}
slice _left, _right;
if (!slice_on_char(uri, ':', &_left, &_right)) { return false; }
// Validate
// necessaru so that e.g. "/some/file:with:a:colon" doesn't become a scheme
// scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
// ALPHA = %x41-5A / %x61-7A ; A-Z / a-z
char first = *_left.start;
if (!(
((first >= 'A') && (first <= 'Z')) ||
((first >= 'a') && (first <= 'z'))
)) { return false; }
for (const char *p = _left.start + 1; p < _left.end; p++)
{
char c = *p;
if (!(
((c >= 'A') && (c <= 'Z')) ||
((c >= 'a') && (c <= 'z')) ||
((c >= '0') && (c <= '9')) ||
(c == '+') ||
(c == '-') ||
(c == '.')
)) { return false; }
}
if (left) { *left = _left; }
if (right) { *right = _right; }
return true;
}
TEST_F(SHAPE, VecAssign)
{\
std::vector<ade::DimT> zerolist = {3, 0, 11, 89};
std::vector<ade::DimT> slist = {52, 58, 35, 46, 77, 80};
std::vector<ade::DimT> junk = {7, 42};
ade::Shape vecassign;
ade::Shape vecassign2(junk);
vecassign = slist;
std::vector<ade::DimT> vlist(vecassign.begin(), vecassign.end());
EXPECT_ARREQ(slist, vlist);
vecassign2 = slist;
std::vector<ade::DimT> vlist2(vecassign2.begin(), vecassign2.end());
EXPECT_ARREQ(slist, vlist2);
std::string fatalmsg = "cannot create shape with vector containing zero: " +
fmts::to_string(zerolist.begin(), zerolist.end());
EXPECT_FATAL(vecassign = zerolist, fatalmsg.c_str());
}
bool connection_open_tcp(connection *con, const char *host, const char *service)
{
EXPECT_FATAL(con);
EXPECT_FATAL(host);
EXPECT_FATAL(service);
EXPECT_FATAL(sizeof(con->mem) >= sizeof(SOCKET));
if (strnlen(host, 256) > 255) { X(bad_arg, XSTR_LIMIT": host must not exceed 255 octets"); }
SOCKET s = INVALID_SOCKET;
// method e.g. "GET"
// host e.g. "example.org"
// rsc e.g. "/index.html"
// port e.g. 80
const struct addrinfo hints =
{
AI_NUMERICSERV | AI_ADDRCONFIG, // ai_flags
AF_UNSPEC, // ai_family: AF_INET | AF_INET6 | AF_UNSPEC
SOCK_STREAM, // ai_socktype (TCP)
IPPROTO_TCP, // ai_protocol (TCP)
0,
NULL,
NULL,
NULL,
};
struct addrinfo *result;
int ret = getaddrinfo(host, service, &hints, &result);
if (ret != 0) { Xf(lookup_address, XSTR_NETWORK": (%s) %s", host, getaddrinfo_strerror(ret)); }
for (struct addrinfo *current = result; current; current = current->ai_next)
{
s = socket(current->ai_family, current->ai_socktype, current->ai_protocol);
if (s == INVALID_SOCKET) { Xf(socket, XSTR_NETWORK ": socket() errno=%d\n", socket_geterr()); }
ret = socket_connect(s, current->ai_addr, current->ai_addrlen);
if (ret != 0) { Xf(connect, XSTR_NETWORK ": connect() errno=%d\n", socket_geterr()); }
memset(con->address, '\0', CFW_INET6_ADDRSTRLEN);
# ifndef TARGET_WINDOWS
if(!inet_ntop(current->ai_family,
&((struct sockaddr_in *) current->ai_addr)->sin_addr,
con->address, CFW_INET6_ADDRSTRLEN)
) { WARNING("inet_ntop() IP lookup failure"); }
# endif
// success
break;
// fallthru
err_connect:
socket_close(s);
err_socket:
continue;
}
freeaddrinfo(result);
if (s == INVALID_SOCKET) { X(no_match, "No matching socket"); }
memcpy(con, &s, sizeof(SOCKET));
strcpy(con->host, host);
return true;
err_no_match:
freeaddrinfo(result);
err_lookup_address:
err_bad_arg:
return false;
}
