TEST(ec, Sign) { static constexpr std::array<u8, 20> HASH{{0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9}}; const std::array<u8, 60> sig = Common::ec::Sign(PRIVATE_KEY.data(), HASH.data()); // r and s must be non-null. EXPECT_FALSE(std::all_of(sig.cbegin(), sig.cbegin() + 30, [](u8 b) { return b == 0; })); EXPECT_FALSE(std::all_of(sig.cbegin() + 30, sig.cend(), [](u8 b) { return b == 0; })); }
CertReader::CertReader(std::vector<u8>&& bytes) : SignedBlobReader(std::move(bytes)) { if (!IsSignatureValid()) return; // XXX: in old GCC versions, capturing 'this' does not work for some lambdas. The workaround // is to not use auto for the parameter (even though the type is obvious). // This can be dropped once we require GCC 7. using CertStructInfo = std::tuple<SignatureType, PublicKeyType, size_t>; static constexpr std::array<CertStructInfo, 4> types{{ {SignatureType::RSA4096, PublicKeyType::RSA2048, sizeof(CertRSA4096RSA2048)}, {SignatureType::RSA2048, PublicKeyType::RSA2048, sizeof(CertRSA2048RSA2048)}, {SignatureType::RSA2048, PublicKeyType::ECC, sizeof(CertRSA2048ECC)}, {SignatureType::ECC, PublicKeyType::ECC, sizeof(CertECC)}, }}; const auto info = std::find_if(types.cbegin(), types.cend(), [this](const CertStructInfo& entry) { return m_bytes.size() >= std::get<2>(entry) && std::get<0>(entry) == GetSignatureType() && std::get<1>(entry) == GetPublicKeyType(); }); if (info == types.cend()) return; m_bytes.resize(std::get<2>(*info)); m_is_valid = true; }
void print_positions(const std::array<position_t, N>& positions) { std::for_each(positions.cbegin(), positions.cend(), [](const position_t& pos) { std::cout << '(' << pos.first << ", " << pos.second << ')' << std::endl; }); }
void FIRC16xR16x32Decim8::configure( const std::array<tap_t, taps_count>& taps, const int32_t scale ) { std::copy(taps.cbegin(), taps.cend(), taps_.begin()); output_scale = scale; z_.fill({}); }
void print_graph(const std::array<std::vector<char>, N>& graph) { int position = 0; std::for_each(graph.cbegin(), graph.cend(), [&](const std::vector<char>& vec) { std::cout << position++ << ": "; print_vec(vec); }); }
std::string CArchiveScanner::ArchiveData::GetKeyDescription(const std::string& keyLower) { const auto pred = [&keyLower](const KnownInfoTag& t) { return (t.name == keyLower); }; const auto iter = std::find_if(knownTags.cbegin(), knownTags.cend(), pred); if (iter != knownTags.cend()) return (iter->desc); return "<custom property>"; }
bool BinaryDependenciesLdd::isLibraryNotInExcludeList(const PlainText::StringRecord & record) { Q_ASSERT(record.columnCount() > 0); const auto cmp = [record](const char * const excludeName){ LibraryName libName(record.data(0)); return ( QString::compare( libName.name(), QLatin1String(excludeName), Qt::CaseSensitive ) == 0); }; const auto it = std::find_if( LibrayExcludeListLinux.cbegin(), LibrayExcludeListLinux.cend(), cmp ); return (it == LibrayExcludeListLinux.cend()); }
bool CArchiveScanner::ArchiveData::IsValid(std::string& err) const { const auto pred = [this](const KnownInfoTag& t) { return (t.required && info.find(t.name) == info.end()); }; const auto iter = std::find_if(knownTags.cbegin(), knownTags.cend(), pred); if (iter == knownTags.cend()) return true; err = "Missing tag \"" + iter->name + "\"."; return false; }
typename std::enable_if< (std::is_integral<T>::value && std::is_floating_point<U>::value && sizeof(T) < sizeof(U)) || (std::is_floating_point<T>::value && std::is_floating_point<U>::value && sizeof(T) <= sizeof(U)) || (std::is_integral<T>::value && std::is_integral<U>::value && ((std::is_unsigned<T>::value && std::is_unsigned<U>::value) || (std::is_signed<T>::value && std::is_signed<U>::value)) && sizeof(T) <= sizeof(U)), void>::type Copy(const std::array<T, N> &src, std::array<U, N> &dst) { std::copy(src.cbegin(), src.cend(), dst.begin()); }
typename std::enable_if< std::is_floating_point<T>::value, void>::type round_to(const std::array<T, N> &src, std::array<U, N> &dst) { auto it_src = src.cbegin(); auto it_dst_end = dst.end(); for (auto it_dst = dst.begin(); it_dst != it_dst_end; ++it_src, ++it_dst) #if _MSC_VER > 1700 // from VS2013 *it_dst = static_cast<U>(std::round(*it_src)); #else // up to VS2013 if (*it_src >= 0) SafeCast(std::floor(*it_src + 0.5), *it_dst); else SafeCast(std::ceil(*it_src - 0.5), *it_dst); #endif }
void SetUp() override { m_nodeIds[0] = 3; m_nodeIds[1] = 1; m_nodeIds[2] = 14; m_nodeIds[3] = 9; m_nodeIdsAsVector.assign(m_nodeIds.cbegin(), m_nodeIds.cend()); m_restState.setNumDof(3, 15); m_invalidState.setNumDof(3, 15); Vector& x0 = m_restState.getPositions(); Vector& invalidx0 = m_invalidState.getPositions(); std::array<Vector3d, 4> points = {{ Vector3d(0.0, 0.0, 0.0), Vector3d(1.0, 0.0, 0.0), Vector3d(0.0, 1.0, 0.0), Vector3d(0.0, 0.0, 1.0) } }; // Tet is aligned with the axis (X,Y,Z), centered on (0.0, 0.0, 0.0), embedded in a cube of size 1 for (size_t nodeId = 0; nodeId < 4; ++nodeId) { SurgSim::Math::getSubVector(x0, m_nodeIds[nodeId], 3) = points[nodeId]; SurgSim::Math::getSubVector(invalidx0, m_nodeIds[nodeId], 3) = points[nodeId]; } // In the invalid state, the tetrahedron is degenerated to a triangle (last 2 points are equal) SurgSim::Math::getSubVector(invalidx0, m_nodeIds[3], 3) = points[2]; m_rho = 1000.0; m_E = 1e6; m_nu = 0.45; Vector3d axis(1.0, 0.2, -0.3); axis.normalize(); m_rotation = SurgSim::Math::makeRotationMatrix(4.1415, axis); m_R12x12 = Eigen::Matrix<double, 12, 12>::Zero(); for (size_t nodeId = 0; nodeId < 4; ++nodeId) { m_R12x12.block<3, 3>(3 * nodeId, 3 * nodeId) = m_rotation; } m_translation = Vector3d(1.2, 2.3, 3.4); }
void app::benchmark::task_func() { #if(APP_BENCHMARK_TYPE == APP_BENCHMARK_TYPE_CRC32) const std::array<std::uint8_t, 9U> data = {{ 0x31U, 0x32U, 0x33U, 0x34U, 0x35U, 0x36U, 0x37U, 0x38U, 0x39U }}; typedef mcal::benchmark::benchmark_port_type port_type; mcal::irq::disable_all(); port_type::set_pin_high(); app_benchmark_crc = math::checksums::crc32_mpeg2(data.cbegin(), data.cend()); port_type::set_pin_low(); mcal::irq::enable_all(); if(app_benchmark_crc == UINT32_C(0x0376E6E7)) { // The benchmark is OK. // Perform one nop and leave. mcal::cpu::nop(); } else { // The benchmark result is not OK! // Remain in a blocking loop and crash the system. for(;;) { mcal::cpu::nop(); } } #endif // APP_BENCHMARK_TYPE == APP_BENCHMARK_TYPE_CRC32 }
void FIR64AndDecimateBy2Real::configure( const std::array<int16_t, taps_count>& new_taps ) { std::copy(new_taps.cbegin(), new_taps.cend(), taps.begin()); }