@zowe/cli 8.36.1 → 8.37.1

package/node_modules/cpu-features/deps/cpu_features/test/filesystem_for_testing.cc

@@ -0,0 +1,103 @@
+// Copyright 2017 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "filesystem_for_testing.h"
+
+#include <cassert>
+#include <climits>
+#include <cstdio>
+#include <cstring>
+#include <utility>
+
+namespace cpu_features {
+
+FakeFile::FakeFile(int file_descriptor, const char* content)
+    : file_descriptor_(file_descriptor), content_(content) {}
+
+FakeFile::~FakeFile() { assert(!opened_); }
+
+void FakeFile::Open() {
+  assert(!opened_);
+  opened_ = true;
+}
+
+void FakeFile::Close() {
+  assert(opened_);
+  opened_ = false;
+}
+
+int FakeFile::Read(int fd, void* buf, size_t count) {
+  assert(count < INT_MAX);
+  assert(fd == file_descriptor_);
+  const size_t remainder = content_.size() - head_index_;
+  const size_t read = count > remainder ? remainder : count;
+  memcpy(buf, content_.data() + head_index_, read);
+  head_index_ += read;
+  assert(read < INT_MAX);
+  return (int)read;
+}
+
+void FakeFilesystem::Reset() { files_.clear(); }
+
+FakeFile* FakeFilesystem::CreateFile(const std::string& filename,
+                                     const char* content) {
+  auto& file = files_[filename];
+  file =
+      std::unique_ptr<FakeFile>(new FakeFile(next_file_descriptor_++, content));
+  return file.get();
+}
+
+FakeFile* FakeFilesystem::FindFileOrNull(const std::string& filename) const {
+  const auto itr = files_.find(filename);
+  return itr == files_.end() ? nullptr : itr->second.get();
+}
+
+FakeFile* FakeFilesystem::FindFileOrDie(const int file_descriptor) const {
+  for (const auto& filename_file_pair : files_) {
+    FakeFile* const file_ptr = filename_file_pair.second.get();
+    if (file_ptr->GetFileDescriptor() == file_descriptor) {
+      return file_ptr;
+    }
+  }
+  assert(false);
+  return nullptr;
+}
+
+static FakeFilesystem* kFilesystem = new FakeFilesystem();
+
+FakeFilesystem& GetEmptyFilesystem() {
+  kFilesystem->Reset();
+  return *kFilesystem;
+}
+
+extern "C" int CpuFeatures_OpenFile(const char* filename) {
+  auto* const file = kFilesystem->FindFileOrNull(filename);
+  if (file) {
+    file->Open();
+    return file->GetFileDescriptor();
+  }
+  return -1;
+}
+
+extern "C" void CpuFeatures_CloseFile(int file_descriptor) {
+  kFilesystem->FindFileOrDie(file_descriptor)->Close();
+}
+
+extern "C" int CpuFeatures_ReadFile(int file_descriptor, void* buffer,
+                                    size_t buffer_size) {
+  return kFilesystem->FindFileOrDie(file_descriptor)
+      ->Read(file_descriptor, buffer, buffer_size);
+}
+
+}  // namespace cpu_features

package/node_modules/cpu-features/deps/cpu_features/test/filesystem_for_testing.h

@@ -0,0 +1,61 @@
+// Copyright 2017 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Implements a fake filesystem, useful for tests.
+#ifndef CPU_FEATURES_TEST_FILESYSTEM_FOR_TESTING_H_
+#define CPU_FEATURES_TEST_FILESYSTEM_FOR_TESTING_H_
+
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+#include "internal/filesystem.h"
+
+namespace cpu_features {
+
+class FakeFile {
+ public:
+  explicit FakeFile(int file_descriptor, const char* content);
+  ~FakeFile();
+
+  void Open();
+  void Close();
+  int Read(int fd, void* buf, size_t count);
+
+  int GetFileDescriptor() const { return file_descriptor_; }
+
+ private:
+  const int file_descriptor_;
+  const std::string content_;
+  bool opened_ = false;
+  size_t head_index_ = 0;
+};
+
+class FakeFilesystem {
+ public:
+  void Reset();
+  FakeFile* CreateFile(const std::string& filename, const char* content);
+  FakeFile* FindFileOrDie(const int file_descriptor) const;
+  FakeFile* FindFileOrNull(const std::string& filename) const;
+
+ private:
+  int next_file_descriptor_ = 0;
+  std::unordered_map<std::string, std::unique_ptr<FakeFile>> files_;
+};
+
+FakeFilesystem& GetEmptyFilesystem();
+
+}  // namespace cpu_features
+
+#endif  // CPU_FEATURES_TEST_FILESYSTEM_FOR_TESTING_H_

package/node_modules/cpu-features/deps/cpu_features/test/hwcaps_for_testing.cc

@@ -0,0 +1,52 @@
+// Copyright 2017 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "hwcaps_for_testing.h"
+
+#include <string.h>
+
+#include "internal/string_view.h"
+
+namespace cpu_features {
+
+namespace {
+static auto* const g_hardware_capabilities = new HardwareCapabilities();
+static const char* g_platform_pointer = nullptr;
+static const char* g_base_platform_pointer = nullptr;
+}  // namespace
+
+void SetHardwareCapabilities(uint32_t hwcaps, uint32_t hwcaps2) {
+  g_hardware_capabilities->hwcaps = hwcaps;
+  g_hardware_capabilities->hwcaps2 = hwcaps2;
+}
+void SetPlatformPointer(const char* string) { g_platform_pointer = string; }
+void SetBasePlatformPointer(const char* string) {
+  g_base_platform_pointer = string;
+}
+
+void ResetHwcaps() {
+  SetHardwareCapabilities(0, 0);
+  SetPlatformPointer(nullptr);
+  SetBasePlatformPointer(nullptr);
+}
+
+HardwareCapabilities CpuFeatures_GetHardwareCapabilities(void) {
+  return *g_hardware_capabilities;
+}
+const char* CpuFeatures_GetPlatformPointer(void) { return g_platform_pointer; }
+const char* CpuFeatures_GetBasePlatformPointer(void) {
+  return g_base_platform_pointer;
+}
+
+}  // namespace cpu_features

package/node_modules/cpu-features/deps/cpu_features/test/hwcaps_for_testing.h

@@ -0,0 +1,31 @@
+// Copyright 2017 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef CPU_FEATURES_TEST_HWCAPS_FOR_TESTING_H_
+#define CPU_FEATURES_TEST_HWCAPS_FOR_TESTING_H_
+
+#include "internal/hwcaps.h"
+
+namespace cpu_features {
+
+void SetHardwareCapabilities(uint32_t hwcaps, uint32_t hwcaps2);
+void SetPlatformPointer(const char* string);
+void SetBasePlatformPointer(const char* string);
+
+// To be called before each test.
+void ResetHwcaps();
+
+}  // namespace cpu_features
+
+#endif  // CPU_FEATURES_TEST_HWCAPS_FOR_TESTING_H_

package/node_modules/cpu-features/deps/cpu_features/test/stack_line_reader_test.cc

@@ -0,0 +1,132 @@
+// Copyright 2017 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "internal/stack_line_reader.h"
+
+#include "filesystem_for_testing.h"
+#include "gtest/gtest.h"
+
+namespace cpu_features {
+
+bool operator==(const StringView& a, const StringView& b) {
+  return CpuFeatures_StringView_IsEquals(a, b);
+}
+
+namespace {
+
+std::string ToString(StringView view) { return {view.ptr, view.size}; }
+
+TEST(StackLineReaderTest, Empty) {
+  auto& fs = GetEmptyFilesystem();
+  auto* file = fs.CreateFile("/proc/cpuinfo", "");
+  StackLineReader reader;
+  StackLineReader_Initialize(&reader, file->GetFileDescriptor());
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_TRUE(result.eof);
+    EXPECT_TRUE(result.full_line);
+    EXPECT_EQ(result.line, str(""));
+  }
+}
+
+TEST(StackLineReaderTest, ManySmallLines) {
+  auto& fs = GetEmptyFilesystem();
+  auto* file = fs.CreateFile("/proc/cpuinfo", "a\nb\nc");
+
+  StackLineReader reader;
+  StackLineReader_Initialize(&reader, file->GetFileDescriptor());
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_FALSE(result.eof);
+    EXPECT_TRUE(result.full_line);
+    EXPECT_EQ(result.line, str("a"));
+  }
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_FALSE(result.eof);
+    EXPECT_TRUE(result.full_line);
+    EXPECT_EQ(result.line, str("b"));
+  }
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_TRUE(result.eof);
+    EXPECT_TRUE(result.full_line);
+    EXPECT_EQ(result.line, str("c"));
+  }
+}
+
+TEST(StackLineReaderTest, TruncatedLine) {
+  auto& fs = GetEmptyFilesystem();
+  auto* file = fs.CreateFile("/proc/cpuinfo", R"(First
+Second
+More than 16 characters, this will be truncated.
+last)");
+
+  StackLineReader reader;
+  StackLineReader_Initialize(&reader, file->GetFileDescriptor());
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_FALSE(result.eof);
+    EXPECT_TRUE(result.full_line);
+    EXPECT_EQ(result.line, str("First"));
+  }
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_FALSE(result.eof);
+    EXPECT_TRUE(result.full_line);
+    EXPECT_EQ(result.line, str("Second"));
+  }
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_FALSE(result.eof);
+    EXPECT_FALSE(result.full_line);
+    EXPECT_EQ(result.line, str("More than 16 cha"));
+  }
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_TRUE(result.eof);
+    EXPECT_TRUE(result.full_line);
+    EXPECT_EQ(result.line, str("last"));
+  }
+}
+
+TEST(StackLineReaderTest, TruncatedLines) {
+  auto& fs = GetEmptyFilesystem();
+  auto* file = fs.CreateFile("/proc/cpuinfo", R"(More than 16 characters
+Another line that is too long)");
+
+  StackLineReader reader;
+  StackLineReader_Initialize(&reader, file->GetFileDescriptor());
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_FALSE(result.eof);
+    EXPECT_FALSE(result.full_line);
+    EXPECT_EQ(result.line, str("More than 16 cha"));
+  }
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_FALSE(result.eof);
+    EXPECT_FALSE(result.full_line);
+    EXPECT_EQ(result.line, str("Another line tha"));
+  }
+  {
+    const auto result = StackLineReader_NextLine(&reader);
+    EXPECT_TRUE(result.eof);
+    EXPECT_TRUE(result.full_line);
+    EXPECT_EQ(result.line, str(""));
+  }
+}
+
+}  // namespace
+}  // namespace cpu_features

package/node_modules/cpu-features/deps/cpu_features/test/string_view_test.cc

@@ -0,0 +1,202 @@
+// Copyright 2017 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "internal/string_view.h"
+
+#include "gtest/gtest.h"
+
+namespace cpu_features {
+
+bool operator==(const StringView& a, const StringView& b) {
+  return CpuFeatures_StringView_IsEquals(a, b);
+}
+
+namespace {
+
+TEST(StringViewTest, Empty) {
+  EXPECT_EQ(kEmptyStringView.ptr, nullptr);
+  EXPECT_EQ(kEmptyStringView.size, 0);
+}
+
+TEST(StringViewTest, Build) {
+  const auto view = str("test");
+  EXPECT_EQ(view.ptr[0], 't');
+  EXPECT_EQ(view.size, 4);
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_IndexOfChar) {
+  // Found.
+  EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(str("test"), 'e'), 1);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(str("test"), 't'), 0);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(str("beef"), 'e'), 1);
+  // Not found.
+  EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(str("test"), 'z'), -1);
+  // Empty.
+  EXPECT_EQ(CpuFeatures_StringView_IndexOfChar(kEmptyStringView, 'z'), -1);
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_IndexOf) {
+  // Found.
+  EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("test"), str("es")), 1);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("test"), str("test")), 0);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("tesstest"), str("test")), 4);
+  // Not found.
+  EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("test"), str("aa")), -1);
+  // Empty.
+  EXPECT_EQ(CpuFeatures_StringView_IndexOf(kEmptyStringView, str("aa")), -1);
+  EXPECT_EQ(CpuFeatures_StringView_IndexOf(str("aa"), kEmptyStringView), -1);
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_StartsWith) {
+  EXPECT_TRUE(CpuFeatures_StringView_StartsWith(str("test"), str("te")));
+  EXPECT_TRUE(CpuFeatures_StringView_StartsWith(str("test"), str("test")));
+  EXPECT_FALSE(CpuFeatures_StringView_StartsWith(str("test"), str("st")));
+  EXPECT_FALSE(CpuFeatures_StringView_StartsWith(str("test"), str("est")));
+  EXPECT_FALSE(CpuFeatures_StringView_StartsWith(str("test"), str("")));
+  EXPECT_FALSE(
+      CpuFeatures_StringView_StartsWith(str("test"), kEmptyStringView));
+  EXPECT_FALSE(
+      CpuFeatures_StringView_StartsWith(kEmptyStringView, str("test")));
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_IsEquals) {
+  EXPECT_TRUE(
+      CpuFeatures_StringView_IsEquals(kEmptyStringView, kEmptyStringView));
+  EXPECT_TRUE(CpuFeatures_StringView_IsEquals(kEmptyStringView, str("")));
+  EXPECT_TRUE(CpuFeatures_StringView_IsEquals(str(""), kEmptyStringView));
+  EXPECT_TRUE(CpuFeatures_StringView_IsEquals(str("test"), str("test")));
+  EXPECT_TRUE(CpuFeatures_StringView_IsEquals(str("a"), str("a")));
+  EXPECT_FALSE(CpuFeatures_StringView_IsEquals(str("a"), str("b")));
+  EXPECT_FALSE(CpuFeatures_StringView_IsEquals(str("aa"), str("a")));
+  EXPECT_FALSE(CpuFeatures_StringView_IsEquals(str("a"), str("aa")));
+  EXPECT_FALSE(CpuFeatures_StringView_IsEquals(str("a"), kEmptyStringView));
+  EXPECT_FALSE(CpuFeatures_StringView_IsEquals(kEmptyStringView, str("a")));
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_PopFront) {
+  EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 2), str("st"));
+  EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 0), str("test"));
+  EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 4), str(""));
+  EXPECT_EQ(CpuFeatures_StringView_PopFront(str("test"), 100), str(""));
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_PopBack) {
+  EXPECT_EQ(CpuFeatures_StringView_PopBack(str("test"), 2), str("te"));
+  EXPECT_EQ(CpuFeatures_StringView_PopBack(str("test"), 0), str("test"));
+  EXPECT_EQ(CpuFeatures_StringView_PopBack(str("test"), 4), str(""));
+  EXPECT_EQ(CpuFeatures_StringView_PopBack(str("test"), 100), str(""));
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_KeepFront) {
+  EXPECT_EQ(CpuFeatures_StringView_KeepFront(str("test"), 2), str("te"));
+  EXPECT_EQ(CpuFeatures_StringView_KeepFront(str("test"), 0), str(""));
+  EXPECT_EQ(CpuFeatures_StringView_KeepFront(str("test"), 4), str("test"));
+  EXPECT_EQ(CpuFeatures_StringView_KeepFront(str("test"), 6), str("test"));
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_Front) {
+  EXPECT_EQ(CpuFeatures_StringView_Front(str("apple")), 'a');
+  EXPECT_EQ(CpuFeatures_StringView_Front(str("a")), 'a');
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_Back) {
+  EXPECT_EQ(CpuFeatures_StringView_Back(str("apple")), 'e');
+  EXPECT_EQ(CpuFeatures_StringView_Back(str("a")), 'a');
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_TrimWhitespace) {
+  EXPECT_EQ(CpuFeatures_StringView_TrimWhitespace(str("  first middle last  ")),
+            str("first middle last"));
+  EXPECT_EQ(CpuFeatures_StringView_TrimWhitespace(str("first middle last  ")),
+            str("first middle last"));
+  EXPECT_EQ(CpuFeatures_StringView_TrimWhitespace(str("  first middle last")),
+            str("first middle last"));
+  EXPECT_EQ(CpuFeatures_StringView_TrimWhitespace(str("first middle last")),
+            str("first middle last"));
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_ParsePositiveNumber) {
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("42")), 42);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("0x2a")), 42);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("0x2A")), 42);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("0x2A2a")), 10794);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("0x2a2A")), 10794);
+
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("-10")), -1);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("-0x2A")), -1);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("abc")), -1);
+  EXPECT_EQ(CpuFeatures_StringView_ParsePositiveNumber(str("")), -1);
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_CopyString) {
+  char buf[4];
+  buf[0] = 'X';
+
+  // Empty
+  CpuFeatures_StringView_CopyString(str(""), buf, sizeof(buf));
+  EXPECT_STREQ(buf, "");
+
+  // Less
+  CpuFeatures_StringView_CopyString(str("a"), buf, sizeof(buf));
+  EXPECT_STREQ(buf, "a");
+
+  // exact
+  CpuFeatures_StringView_CopyString(str("abc"), buf, sizeof(buf));
+  EXPECT_STREQ(buf, "abc");
+
+  // More
+  CpuFeatures_StringView_CopyString(str("abcd"), buf, sizeof(buf));
+  EXPECT_STREQ(buf, "abc");
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_HasWord) {
+  // Find flags at beginning, middle and end.
+  EXPECT_TRUE(
+      CpuFeatures_StringView_HasWord(str("first middle last"), "first", ' '));
+  EXPECT_TRUE(
+      CpuFeatures_StringView_HasWord(str("first middle last"), "middle", ' '));
+  EXPECT_TRUE(
+      CpuFeatures_StringView_HasWord(str("first middle last"), "last", ' '));
+  // Find flags at beginning, middle and end with a different separator
+  EXPECT_TRUE(
+      CpuFeatures_StringView_HasWord(str("first-middle-last"), "first", '-'));
+  EXPECT_TRUE(
+      CpuFeatures_StringView_HasWord(str("first-middle-last"), "middle", '-'));
+  EXPECT_TRUE(
+      CpuFeatures_StringView_HasWord(str("first-middle-last"), "last", '-'));
+  // Do not match partial flags
+  EXPECT_FALSE(
+      CpuFeatures_StringView_HasWord(str("first middle last"), "irst", ' '));
+  EXPECT_FALSE(
+      CpuFeatures_StringView_HasWord(str("first middle last"), "mid", ' '));
+  EXPECT_FALSE(
+      CpuFeatures_StringView_HasWord(str("first middle last"), "las", ' '));
+}
+
+TEST(StringViewTest, CpuFeatures_StringView_GetAttributeKeyValue) {
+  const StringView line = str(" key :   first middle last   ");
+  StringView key, value;
+  EXPECT_TRUE(CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value));
+  EXPECT_EQ(key, str("key"));
+  EXPECT_EQ(value, str("first middle last"));
+}
+
+TEST(StringViewTest, FailingGetAttributeKeyValue) {
+  const StringView line = str("key  first middle last");
+  StringView key, value;
+  EXPECT_FALSE(CpuFeatures_StringView_GetAttributeKeyValue(line, &key, &value));
+}
+
+}  // namespace
+}  // namespace cpu_features

package/node_modules/cpu-features/lib/index.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const binding = require('../build/Release/cpufeatures.node');
+
+module.exports = binding.getCPUInfo;

package/node_modules/cpu-features/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "cpu-features",
+  "version": "0.0.9",
+  "author": "Brian White <mscdex@mscdex.net>",
+  "description": "A simple binding to Google's cpu_features library for obtaining information about installed CPU(s)",
+  "main": "./lib/index",
+  "dependencies": {
+    "buildcheck": "~0.0.6",
+    "nan": "^2.17.0"
+  },
+  "devDependencies": {
+    "@mscdex/eslint-config": "^1.1.0",
+    "eslint": "^7.0.0"
+  },
+  "scripts": {
+    "install": "node buildcheck.js > buildcheck.gypi && node-gyp rebuild",
+    "test": "node test/test.js",
+    "lint": "eslint --cache --report-unused-disable-directives --ext=.js .eslintrc.js lib test",
+    "lint:fix": "npm run lint -- --fix"
+  },
+  "engines": {
+    "node": ">=10.0.0"
+  },
+  "keywords": [
+    "cpu",
+    "detect",
+    "detection",
+    "features"
+  ],
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "https://github.com/mscdex/cpu-features/raw/master/LICENSE"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mscdex/cpu-features.git"
+  }
+}