diff --git a/Android.mk b/Android.mk
index fa3a9c3..267c786 100644
--- a/Android.mk
+++ b/Android.mk
@@ -65,9 +65,9 @@
     system/chre/platform/shared/include \
     system/chre/platform/slpi/include \
     system/chre/util/include \
-    system/core/base/include \
+    system/libbase/include \
     system/core/libcutils/include \
-    system/core/liblog/include \
+    system/logging/liblog/include \
     system/core/libutils/include \
 
 LOCAL_SHARED_LIBRARIES := \
diff --git a/build/arch/x86.mk b/build/arch/x86.mk
index 695bd5a..0c5ce6b 100644
--- a/build/arch/x86.mk
+++ b/build/arch/x86.mk
@@ -9,7 +9,7 @@
          containing a path to the Android source tree. This is typically \
          provided by initializing the Android build environment.")
 endif
-export X86_TOOLS_PREFIX=$(ANDROID_BUILD_TOP)/prebuilts/clang/host/linux-x86/clang-r370808/bin/
+export X86_TOOLS_PREFIX=$(ANDROID_BUILD_TOP)/prebuilts/clang/host/linux-x86/clang-r383902c/bin/
 
 # x86 Tools ####################################################################
 
@@ -28,6 +28,9 @@
 # Enable position independence.
 TARGET_CFLAGS += -fpic
 
+# Disable double promotion warning for logging
+TARGET_CFLAGS += -Wno-double-promotion
+
 # x86 Shared Object Linker Flags ###############################################
 
 TARGET_SO_LDFLAGS += -shared
diff --git a/build/variant/google_x86_googletest.mk b/build/variant/google_x86_googletest.mk
index 3e6313b..eb48c7b 100644
--- a/build/variant/google_x86_googletest.mk
+++ b/build/variant/google_x86_googletest.mk
@@ -7,7 +7,14 @@
 TARGET_NAME = google_x86_googletest
 TARGET_CFLAGS = -DCHRE_MESSAGE_TO_HOST_MAX_SIZE=2048
 TARGET_VARIANT_SRCS = $(GOOGLE_X86_GOOGLETEST_SRCS)
+TARGET_VARIANT_SRCS += $(GOOGLETEST_COMMON_SRCS)
+
+ifeq ($(RUN_PAL_IMPL_TESTS), true)
+TARGET_VARIANT_SRCS += $(GOOGLETEST_PAL_IMPL_SRCS)
+else
 TARGET_VARIANT_SRCS += $(GOOGLETEST_SRCS)
+endif
+
 TARGET_PLATFORM_ID = 0x476f6f676c000001
 
 TARGET_CFLAGS += $(SIM_CFLAGS)
diff --git a/java/test/settings/src/com/google/android/chre/test/setting/ContextHubWifiSettingsTestExecutor.java b/java/test/settings/src/com/google/android/chre/test/setting/ContextHubWifiSettingsTestExecutor.java
index ae3a09b..50d740d 100644
--- a/java/test/settings/src/com/google/android/chre/test/setting/ContextHubWifiSettingsTestExecutor.java
+++ b/java/test/settings/src/com/google/android/chre/test/setting/ContextHubWifiSettingsTestExecutor.java
@@ -22,6 +22,7 @@
 import android.content.IntentFilter;
 import android.hardware.location.NanoAppBinary;
 import android.net.wifi.WifiManager;
+import android.util.Log;
 
 import androidx.test.InstrumentationRegistry;
 
@@ -37,6 +38,7 @@
  * A test to check for behavior when WiFi settings are changed.
  */
 public class ContextHubWifiSettingsTestExecutor {
+    private static final String TAG = "ContextHubWifiSettingsTestExecutor";
     private final ContextHubSettingsTestExecutor mExecutor;
 
     private final Instrumentation mInstrumentation = InstrumentationRegistry.getInstrumentation();
@@ -87,6 +89,9 @@
         mInitialLocationEnabled = mSettingsUtil.isLocationEnabled();
         mInitialWifiEnabled = mSettingsUtil.isWifiEnabled();
         mInitialWifiScanningAlwaysEnabled = mSettingsUtil.isWifiScanningAlwaysEnabled();
+        Log.d(TAG, "isLocationEnalbed=" + mInitialLocationEnabled
+                + ", isWifiEnabled=" + mInitialWifiEnabled
+                + ", isWifiScanningAlwaysEnabled=" + mInitialWifiScanningAlwaysEnabled);
         mExecutor.init();
     }
 
@@ -127,7 +132,7 @@
             wifiUpdateListener.mWifiLatch.await(30, TimeUnit.SECONDS);
 
             // Wait a few seconds to ensure setting is propagated to CHRE path
-            Thread.sleep(5000);
+            Thread.sleep(10000);
         } catch (InterruptedException e) {
             Assert.fail(e.getMessage());
         }
diff --git a/pal/pal.mk b/pal/pal.mk
index 0c92ecf..bf4dd46 100644
--- a/pal/pal.mk
+++ b/pal/pal.mk
@@ -9,5 +9,8 @@
 
 # GoogleTest Source Files ######################################################
 
-GOOGLETEST_SRCS += pal/tests/version_test.cc
-GOOGLETEST_SRCS += pal/tests/wwan_test.cc
+GOOGLETEST_CFLAGS += -Ipal/tests/include
+GOOGLETEST_SRCS += pal/tests/src/version_test.cc
+GOOGLETEST_SRCS += pal/tests/src/wwan_test.cc
+GOOGLETEST_PAL_IMPL_SRCS += pal/tests/src/gnss_pal_impl_test.cc
+GOOGLETEST_PAL_IMPL_SRCS += pal/tests/src/wifi_pal_impl_test.cc
diff --git a/pal/tests/include/gnss_pal_impl_test.h b/pal/tests/include/gnss_pal_impl_test.h
new file mode 100644
index 0000000..b69e960
--- /dev/null
+++ b/pal/tests/include/gnss_pal_impl_test.h
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * 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 GNSSPAL_IMPL_TEST_H_
+#define GNSSPAL_IMPL_TEST_H_
+
+#include "chre/pal/gnss.h"
+#include "chre/platform/condition_variable.h"
+#include "chre/platform/mutex.h"
+#include "chre/util/fixed_size_vector.h"
+#include "chre/util/time.h"
+#include "gtest/gtest.h"
+
+namespace gnss_pal_impl_test {
+
+class PalGnssTest : public ::testing::Test {
+ public:
+  /**
+   * Implements CHRE PAL API callbacks
+   */
+  void requestStateResync();
+  void locationStatusChangeCallback(bool enabled, uint8_t errorCode);
+  void locationEventCallback(struct chreGnssLocationEvent *event);
+  void measurementStatusChangeCallback(bool enabled, uint8_t errorCode);
+  void measurementEventCallback(struct chreGnssDataEvent *event);
+
+ protected:
+  void SetUp() override;
+
+  void TearDown() override;
+
+  /**
+   * Prepares for a subsequent PAL API call that expects an async response.
+   */
+  void prepareForAsyncResponse() {
+    errorCode_ = CHRE_ERROR_LAST;
+  }
+
+  /**
+   * Waits for an async response by the PAL implementation (e.g. via location
+   * or measurement status change callback), and asserts that a success
+   * error code was received.
+   */
+  void waitForAsyncResponseAssertSuccess(chre::Nanoseconds timeoutNs);
+
+  //! The pointer to the CHRE PAL implementation API
+  const struct chrePalGnssApi *api_;
+
+  //! The error code of the most recent callback
+  uint8_t errorCode_ = CHRE_ERROR_LAST;
+
+  //! True if location session is currently enabled
+  bool locationSessionEnabled_ = false;
+
+  //! True if location session is currently enabled
+  bool measurementSessionEnabled_ = false;
+
+  //! A list to store the location events
+  static constexpr size_t kEventArraySize = 5;
+  chre::FixedSizeVector<chreGnssLocationEvent *, kEventArraySize>
+      locationEventVector_;
+  chre::FixedSizeVector<chreGnssDataEvent *, kEventArraySize>
+      measurementEventVector_;
+
+  //! Mutex to protect class variables
+  chre::Mutex mutex_;
+  chre::ConditionVariable condVar_;
+};
+
+}  // namespace gnss_pal_impl_test
+
+#endif  // GNSSPAL_IMPL_TEST_H_
diff --git a/pal/tests/include/wifi_pal_impl_test.h b/pal/tests/include/wifi_pal_impl_test.h
new file mode 100644
index 0000000..2188ea6
--- /dev/null
+++ b/pal/tests/include/wifi_pal_impl_test.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * 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 WIFI_PAL_IMPL_TEST_H_
+#define WIFI_PAL_IMPL_TEST_H_
+
+#include "chre/pal/wifi.h"
+#include "chre/platform/condition_variable.h"
+#include "chre/platform/mutex.h"
+#include "chre/util/dynamic_vector.h"
+#include "chre/util/optional.h"
+#include "chre/util/time.h"
+#include "gtest/gtest.h"
+
+namespace wifi_pal_impl_test {
+
+class PalWifiTest : public ::testing::Test {
+ public:
+  /**
+   * Implements CHRE PAL API callbacks
+   */
+  void scanMonitorStatusChangeCallback(bool enabled, uint8_t errorCode);
+  void scanResponseCallback(bool pending, uint8_t errorCode);
+  void scanEventCallback(struct chreWifiScanEvent *event);
+  void rangingEventCallback(uint8_t errorCode,
+                            struct chreWifiRangingEvent *event);
+
+ protected:
+  void SetUp() override;
+
+  void TearDown() override;
+
+  /**
+   * Validates an incoming WiFi scan event.
+   *
+   * @param event The WiFi scan event.
+   */
+  void validateWifiScanEvent(const chreWifiScanEvent &event);
+
+  /**
+   * Prepares for a subsequent PAL API call that expects an async response.
+   */
+  void prepareForAsyncResponse() {
+    errorCode_ = CHRE_ERROR_LAST;
+  }
+
+  /**
+   * Waits for an async response by the PAL implementation (e.g. via scan
+   * response/monitor status change callback), and asserts that a success
+   * error code was received.
+   */
+  void waitForAsyncResponseAssertSuccess(chre::Nanoseconds timeoutNs);
+
+  //! The pointer to the CHRE PAL implementation API
+  const struct chrePalWifiApi *api_;
+
+  //! The error code of the most recent callback
+  uint8_t errorCode_ = CHRE_ERROR_LAST;
+
+  //! The number of scan events currently stored
+  uint32_t numScanResultCount_ = 0;
+
+  //! True if the last scan event has been received
+  bool lastScanEventReceived_ = false;
+
+  //! A list to store the scan results
+  chre::DynamicVector<chreWifiScanEvent *> scanEventList_;
+
+  //! Stores active scan params
+  chre::Optional<chreWifiScanParams> scanParams_;
+
+  //! The last scan event index received, UINT8_MAX if invalid
+  uint8_t lastEventIndex_;
+
+  //! True if scan monitoring is currently enabled
+  bool scanMonitorEnabled_ = false;
+
+  //! Mutex to protect class variables
+  chre::Mutex mutex_;
+  chre::ConditionVariable condVar_;
+};
+
+}  // namespace wifi_pal_impl_test
+
+#endif  // WIFI_PAL_IMPL_TEST_H_
diff --git a/pal/tests/src/gnss_pal_impl_test.cc b/pal/tests/src/gnss_pal_impl_test.cc
new file mode 100644
index 0000000..bbb92e9
--- /dev/null
+++ b/pal/tests/src/gnss_pal_impl_test.cc
@@ -0,0 +1,317 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * 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 "gnss_pal_impl_test.h"
+
+#include "chre/platform/log.h"
+#include "chre/platform/shared/pal_system_api.h"
+#include "chre/platform/system_time.h"
+#include "chre/util/lock_guard.h"
+
+#include <cinttypes>
+
+//! Flag to require GNSS location sessions capability to be enabled for the test
+//! to pass. Set to false to allow tests to pass on disabled platforms.
+//! Note that it is required to run this test where location can be acquired.
+//! The constants kGnssEventTimeoutNs and kEventArraySize may be tuned if
+//! applicable.
+#ifndef PAL_IMPL_TEST_GNSS_LOCATION_REQUIRED
+#define PAL_IMPL_TEST_GNSS_LOCATION_REQUIRED true
+#endif
+
+//! Same as above for GNSS measurement sessions.
+#ifndef PAL_IMPL_TEST_GNSS_MEASUREMENTS_REQUIRED
+#define PAL_IMPL_TEST_GNSS_MEASUREMENTS_REQUIRED true
+#endif
+
+namespace gnss_pal_impl_test {
+
+namespace {
+
+using ::chre::Nanoseconds;
+using ::chre::Seconds;
+using ::chre::SystemTime;
+
+//! A pointer to the current test running
+gnss_pal_impl_test::PalGnssTest *gTest = nullptr;
+
+//! Timeout as specified by the CHRE API
+const Nanoseconds kGnssAsyncResultTimeoutNs =
+    Nanoseconds(CHRE_GNSS_ASYNC_RESULT_TIMEOUT_NS);
+
+//! Timeout to wait for kEventArraySize events.
+const Nanoseconds kGnssEventTimeoutNs = Seconds(60);
+
+void chrePalRequestStateResync() {
+  if (gTest != nullptr) {
+    gTest->requestStateResync();
+  }
+}
+
+void chrePalLocationStatusChangeCallback(bool enabled, uint8_t errorCode) {
+  if (gTest != nullptr) {
+    gTest->locationStatusChangeCallback(enabled, errorCode);
+  }
+}
+
+void chrePalLocationEventCallback(struct chreGnssLocationEvent *event) {
+  if (gTest != nullptr) {
+    gTest->locationEventCallback(event);
+  }
+}
+
+void chrePalMeasurementStatusChangeCallback(bool enabled, uint8_t errorCode) {
+  if (gTest != nullptr) {
+    gTest->measurementStatusChangeCallback(enabled, errorCode);
+  }
+}
+
+void chrePalMeasurementEventCallback(struct chreGnssDataEvent *event) {
+  if (gTest != nullptr) {
+    gTest->measurementEventCallback(event);
+  }
+}
+
+void logLocationEvent(const struct chreGnssLocationEvent &event) {
+  LOGI("Received location: %" PRId32 ", %" PRId32, event.latitude_deg_e7,
+       event.longitude_deg_e7);
+  LOGI("  timestamp (ms): %" PRIu64, event.timestamp);
+  LOGI("  altitude (m): %f", event.altitude);
+  LOGI("  speed (m/s): %f", event.speed);
+  LOGI("  bearing (deg): %f", event.bearing);
+  LOGI("  accuracy: %f", event.accuracy);
+  LOGI("  flags: 0x%" PRIx16, event.flags);
+  LOGI("  altitude_accuracy: %f", event.altitude_accuracy);
+  LOGI("  speed_accuracy: %f", event.speed_accuracy);
+  LOGI("  bearing_accuracy: %f", event.bearing_accuracy);
+}
+
+void validateLocationEvent(const struct chreGnssLocationEvent &event) {
+  static uint64_t sLastTimestampNs = 0;
+  EXPECT_GE(event.timestamp, sLastTimestampNs);
+  sLastTimestampNs = event.timestamp;
+  if (event.flags & CHRE_GPS_LOCATION_HAS_LAT_LONG) {
+    EXPECT_GE(event.latitude_deg_e7, -90 * 1e7);
+    EXPECT_LE(event.latitude_deg_e7, 90 * 1e7);
+    EXPECT_GE(event.longitude_deg_e7, -180 * 1e7);
+    EXPECT_LE(event.longitude_deg_e7, 180 * 1e7);
+  }
+  if (event.flags & CHRE_GPS_LOCATION_HAS_BEARING) {
+    EXPECT_GE(event.bearing, 0);
+    EXPECT_LT(event.bearing, 360);  // [0, 360) per API
+  }
+}
+
+void logMeasurementEvent(const struct chreGnssDataEvent &event) {
+  LOGI("Received data: %" PRIu8 " measurements", event.measurement_count);
+
+  for (uint8_t i = 0; i < event.measurement_count; i++) {
+    LOGI("%" PRIu8 ": const %" PRIu8 ", cn0 %.2f, freq %.3f MHz", i,
+         event.measurements[i].constellation, event.measurements[i].c_n0_dbhz,
+         event.measurements[i].carrier_frequency_hz / 1e6);
+  }
+}
+
+void validateMeasurementEvent(const struct chreGnssDataEvent &event) {
+  EXPECT_GE(event.measurement_count, 0);
+  EXPECT_LE(event.measurement_count, CHRE_GNSS_MAX_MEASUREMENT);
+  if (event.measurement_count > 0) {
+    EXPECT_NE(event.measurements, nullptr);
+  }
+
+  static int64_t sLastClockTimeNs = INT64_MIN;
+  EXPECT_GE(event.clock.time_ns, sLastClockTimeNs);
+  sLastClockTimeNs = event.clock.time_ns;
+
+  for (uint8_t i = 0; i < event.measurement_count; i++) {
+    EXPECT_GE(event.measurements[i].c_n0_dbhz, 0);
+    EXPECT_LE(event.measurements[i].c_n0_dbhz, 63);
+  }
+}
+
+}  // anonymous namespace
+
+void PalGnssTest::SetUp() {
+  api_ = chrePalGnssGetApi(CHRE_PAL_GNSS_API_CURRENT_VERSION);
+  ASSERT_NE(api_, nullptr);
+  EXPECT_EQ(api_->moduleVersion, CHRE_PAL_GNSS_API_CURRENT_VERSION);
+
+  // Open the PAL API
+  static const struct chrePalGnssCallbacks kCallbacks = {
+      .requestStateResync = chrePalRequestStateResync,
+      .locationStatusChangeCallback = chrePalLocationStatusChangeCallback,
+      .locationEventCallback = chrePalLocationEventCallback,
+      .measurementStatusChangeCallback = chrePalMeasurementStatusChangeCallback,
+      .measurementEventCallback = chrePalMeasurementEventCallback,
+  };
+  ASSERT_TRUE(api_->open(&chre::gChrePalSystemApi, &kCallbacks));
+  gTest = this;
+
+  errorCode_ = CHRE_ERROR_LAST;
+  locationSessionEnabled_ = false;
+  locationEventVector_.resize(0);
+  measurementSessionEnabled_ = false;
+  measurementEventVector_.resize(0);
+}
+
+void PalGnssTest::TearDown() {
+  gTest = nullptr;
+  api_->close();
+}
+
+void PalGnssTest::requestStateResync() {
+  // TODO:
+}
+
+void PalGnssTest::locationStatusChangeCallback(bool enabled,
+                                               uint8_t errorCode) {
+  LOGI("Received location status change with enabled %d error %" PRIu8, enabled,
+       errorCode);
+  if (errorCode == CHRE_ERROR_LAST) {
+    LOGE("Received CHRE_ERROR_LAST");
+    errorCode = CHRE_ERROR;
+  }
+  chre::LockGuard<chre::Mutex> lock(mutex_);
+  errorCode_ = errorCode;
+  locationSessionEnabled_ = enabled;
+  condVar_.notify_one();
+}
+
+void PalGnssTest::locationEventCallback(struct chreGnssLocationEvent *event) {
+  LOGI("Received location event");
+  chre::LockGuard<chre::Mutex> lock(mutex_);
+  if (!locationEventVector_.full()) {
+    locationEventVector_.push_back(event);
+    if (locationEventVector_.full()) {
+      condVar_.notify_one();
+    }
+  }
+}
+
+void PalGnssTest::measurementStatusChangeCallback(bool enabled,
+                                                  uint8_t errorCode) {
+  LOGI("Received measurement status change with enabled %d error %" PRIu8,
+       enabled, errorCode);
+  if (errorCode == CHRE_ERROR_LAST) {
+    LOGE("Received CHRE_ERROR_LAST");
+    errorCode = CHRE_ERROR;
+  }
+  chre::LockGuard<chre::Mutex> lock(mutex_);
+  errorCode_ = errorCode;
+  measurementSessionEnabled_ = enabled;
+  condVar_.notify_one();
+}
+
+void PalGnssTest::measurementEventCallback(struct chreGnssDataEvent *event) {
+  LOGI("Received measurement event");
+  chre::LockGuard<chre::Mutex> lock(mutex_);
+  if (!measurementEventVector_.full()) {
+    measurementEventVector_.push_back(event);
+    if (measurementEventVector_.full()) {
+      condVar_.notify_one();
+    }
+  }
+}
+
+void PalGnssTest::waitForAsyncResponseAssertSuccess(
+    chre::Nanoseconds timeoutNs) {
+  bool waitSuccess = true;
+  while (errorCode_ == CHRE_ERROR_LAST && waitSuccess) {
+    waitSuccess = condVar_.wait_for(mutex_, timeoutNs);
+  }
+  ASSERT_TRUE(waitSuccess);
+  ASSERT_EQ(errorCode_, CHRE_ERROR_NONE);
+}
+
+TEST_F(PalGnssTest, LocationSessionTest) {
+  bool hasLocationCapability =
+      ((api_->getCapabilities() & CHRE_GNSS_CAPABILITIES_LOCATION) ==
+       CHRE_GNSS_CAPABILITIES_LOCATION);
+#if PAL_IMPL_TEST_GNSS_LOCATION_REQUIRED
+  ASSERT_TRUE(hasLocationCapability);
+#else
+  if (!hasLocationCapability) {
+    GTEST_SKIP();
+  }
+#endif
+
+  chre::LockGuard<chre::Mutex> lock(mutex_);
+
+  prepareForAsyncResponse();
+  ASSERT_TRUE(api_->controlLocationSession(
+      true /* enable */, 1000 /* minIntervalMs */, 0 /* minTimeToNextFixMs */));
+  waitForAsyncResponseAssertSuccess(kGnssAsyncResultTimeoutNs);
+  ASSERT_TRUE(locationSessionEnabled_);
+
+  bool waitSuccess = true;
+  while (!locationEventVector_.full() && waitSuccess) {
+    waitSuccess = condVar_.wait_for(mutex_, kGnssEventTimeoutNs);
+  }
+
+  for (size_t i = 0; i < locationEventVector_.size(); i++) {
+    logLocationEvent(*locationEventVector_[i]);
+    validateLocationEvent(*locationEventVector_[i]);
+    api_->releaseLocationEvent(locationEventVector_[i]);
+  }
+  EXPECT_TRUE(locationEventVector_.full());
+
+  prepareForAsyncResponse();
+  ASSERT_TRUE(api_->controlLocationSession(
+      false /* enable */, 0 /* minIntervalMs */, 0 /* minTimeToNextFixMs */));
+  waitForAsyncResponseAssertSuccess(kGnssAsyncResultTimeoutNs);
+  ASSERT_FALSE(locationSessionEnabled_);
+}
+
+TEST_F(PalGnssTest, MeasurementSessionTest) {
+  bool hasMeasurementCapability =
+      ((api_->getCapabilities() & CHRE_GNSS_CAPABILITIES_MEASUREMENTS) ==
+       CHRE_GNSS_CAPABILITIES_MEASUREMENTS);
+#if PAL_IMPL_TEST_GNSS_MEAUSUREMENT_REQUIRED
+  ASSERT_TRUE(hasMeasurementCapability);
+#else
+  if (!hasMeasurementCapability) {
+    GTEST_SKIP();
+  }
+#endif
+
+  chre::LockGuard<chre::Mutex> lock(mutex_);
+
+  prepareForAsyncResponse();
+  ASSERT_TRUE(api_->controlMeasurementSession(true /* enable */,
+                                              1000 /* minIntervalMs */));
+  waitForAsyncResponseAssertSuccess(kGnssAsyncResultTimeoutNs);
+  ASSERT_TRUE(measurementSessionEnabled_);
+
+  bool waitSuccess = true;
+  while (!measurementEventVector_.full() && waitSuccess) {
+    waitSuccess = condVar_.wait_for(mutex_, kGnssEventTimeoutNs);
+  }
+  EXPECT_TRUE(measurementEventVector_.full());
+
+  for (size_t i = 0; i < measurementEventVector_.size(); i++) {
+    logMeasurementEvent(*measurementEventVector_[i]);
+    validateMeasurementEvent(*measurementEventVector_[i]);
+    api_->releaseMeasurementDataEvent(measurementEventVector_[i]);
+  }
+
+  prepareForAsyncResponse();
+  ASSERT_TRUE(api_->controlMeasurementSession(false /* enable */,
+                                              0 /* minIntervalMs */));
+  waitForAsyncResponseAssertSuccess(kGnssAsyncResultTimeoutNs);
+  ASSERT_FALSE(measurementSessionEnabled_);
+}
+
+}  // namespace gnss_pal_impl_test
diff --git a/pal/tests/version_test.cc b/pal/tests/src/version_test.cc
similarity index 100%
rename from pal/tests/version_test.cc
rename to pal/tests/src/version_test.cc
diff --git a/pal/tests/src/wifi_pal_impl_test.cc b/pal/tests/src/wifi_pal_impl_test.cc
new file mode 100644
index 0000000..a266a6b
--- /dev/null
+++ b/pal/tests/src/wifi_pal_impl_test.cc
@@ -0,0 +1,285 @@
+/*
+ * Copyright (C) 2020 The Android Open Source Project
+ *
+ * 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 "wifi_pal_impl_test.h"
+
+#include "chre/platform/log.h"
+#include "chre/platform/shared/pal_system_api.h"
+#include "chre/platform/system_time.h"
+#include "chre/util/lock_guard.h"
+#include "chre/util/nanoapp/wifi.h"
+
+#include <cinttypes>
+
+// Flag to require on-demand WiFi scanning capability to be enabled for the test
+// to pass. Set to false to allow tests to pass on disabled platforms.
+#ifndef PAL_IMPL_TEST_WIFI_ON_DEMAND_SCAN_REQUIRED
+#define PAL_IMPL_TEST_WIFI_ON_DEMAND_SCAN_REQUIRED true
+#endif
+
+// Same as above for scan monitoring.
+#ifndef PAL_IMPL_TEST_WIFI_SCAN_MONITORING_REQUIRED
+#define PAL_IMPL_TEST_WIFI_SCAN_MONITORING_REQUIRED true
+#endif
+
+namespace wifi_pal_impl_test {
+
+namespace {
+
+using ::chre::Nanoseconds;
+using ::chre::Seconds;
+using ::chre::SystemTime;
+
+//! A pointer to the current test running
+wifi_pal_impl_test::PalWifiTest *gTest = nullptr;
+
+//! Timeout as specified by the CHRE API
+const Nanoseconds kAsyncResultTimeoutNs =
+    Nanoseconds(CHRE_ASYNC_RESULT_TIMEOUT_NS);
+const Nanoseconds kScanResultTimeoutNs =
+    Nanoseconds(CHRE_WIFI_SCAN_RESULT_TIMEOUT_NS);
+
+void chrePalScanMonitorStatusChangeCallback(bool enabled, uint8_t errorCode) {
+  if (gTest != nullptr) {
+    gTest->scanMonitorStatusChangeCallback(enabled, errorCode);
+  }
+}
+
+void chrePalScanResponseCallback(bool pending, uint8_t errorCode) {
+  if (gTest != nullptr) {
+    gTest->scanResponseCallback(pending, errorCode);
+  }
+}
+
+void chrePalScanEventCallback(struct chreWifiScanEvent *event) {
+  if (gTest != nullptr) {
+    gTest->scanEventCallback(event);
+  }
+}
+
+void chrePalRangingEventCallback(uint8_t errorCode,
+                                 struct chreWifiRangingEvent *event) {
+  if (gTest != nullptr) {
+    gTest->rangingEventCallback(errorCode, event);
+  }
+}
+
+void logChreWifiResult(const chreWifiScanResult &result) {
+  const char *ssidStr = "<non-printable>";
+  char ssidBuffer[chre::kMaxSsidStrLen];
+  if (result.ssidLen == 0) {
+    ssidStr = "<empty>";
+  } else if (chre::parseSsidToStr(ssidBuffer, sizeof(ssidBuffer), result.ssid,
+                                  result.ssidLen)) {
+    ssidStr = ssidBuffer;
+  }
+
+  LOGI("Found network with SSID: %s", ssidStr);
+  const char *bssidStr = "<non-printable>";
+  char bssidBuffer[chre::kBssidStrLen];
+  if (chre::parseBssidToStr(result.bssid, bssidBuffer, sizeof(bssidBuffer))) {
+    bssidStr = bssidBuffer;
+  }
+
+  LOGI("  age (ms): %" PRIu32, result.ageMs);
+  LOGI("  capability info: 0x%" PRIx16, result.capabilityInfo);
+  LOGI("  bssid: %s", bssidStr);
+  LOGI("  flags: 0x%" PRIx8, result.flags);
+  LOGI("  rssi: %" PRId8 "dBm", result.rssi);
+  LOGI("  band: %s (%" PRIu8 ")", chre::parseChreWifiBand(result.band),
+       result.band);
+  LOGI("  primary channel: %" PRIu32, result.primaryChannel);
+  LOGI("  center frequency primary: %" PRIu32, result.centerFreqPrimary);
+  LOGI("  center frequency secondary: %" PRIu32, result.centerFreqSecondary);
+  LOGI("  channel width: %" PRIu8, result.channelWidth);
+  LOGI("  security mode: 0x%" PRIx8, result.securityMode);
+}
+
+}  // anonymous namespace
+
+void PalWifiTest::SetUp() {
+  api_ = chrePalWifiGetApi(CHRE_PAL_WIFI_API_CURRENT_VERSION);
+  ASSERT_NE(api_, nullptr);
+  EXPECT_EQ(api_->moduleVersion, CHRE_PAL_WIFI_API_CURRENT_VERSION);
+
+  // Open the PAL API
+  static const struct chrePalWifiCallbacks kCallbacks = {
+      .scanMonitorStatusChangeCallback = chrePalScanMonitorStatusChangeCallback,
+      .scanResponseCallback = chrePalScanResponseCallback,
+      .scanEventCallback = chrePalScanEventCallback,
+      .rangingEventCallback = chrePalRangingEventCallback,
+  };
+  ASSERT_TRUE(api_->open(&chre::gChrePalSystemApi, &kCallbacks));
+  gTest = this;
+
+  errorCode_ = CHRE_ERROR_LAST;
+  numScanResultCount_ = 0;
+  lastScanEventReceived_ = false;
+  scanEventList_.clear();
+  scanParams_.reset();
+  lastEventIndex_ = UINT8_MAX;
+  scanMonitorEnabled_ = false;
+}
+
+void PalWifiTest::TearDown() {
+  gTest = nullptr;
+  api_->close();
+}
+
+void PalWifiTest::scanMonitorStatusChangeCallback(bool enabled,
+                                                  uint8_t errorCode) {
+  LOGI("Received scan monitor response with enabled %d error %" PRIu8, enabled,
+       errorCode);
+  if (errorCode == CHRE_ERROR_LAST) {
+    LOGE("Received CHRE_ERROR_LAST");
+    errorCode = CHRE_ERROR;
+  }
+  chre::LockGuard<chre::Mutex> lock(mutex_);
+  scanMonitorEnabled_ = enabled;
+  errorCode_ = errorCode;
+  condVar_.notify_one();
+}
+
+void PalWifiTest::scanResponseCallback(bool pending, uint8_t errorCode) {
+  LOGI("Received scan response with pending %d error %" PRIu8, pending,
+       errorCode);
+  if (errorCode == CHRE_ERROR_LAST) {
+    LOGE("Received CHRE_ERROR_LAST");
+    errorCode = CHRE_ERROR;
+  }
+  chre::LockGuard<chre::Mutex> lock(mutex_);
+  errorCode_ = errorCode;
+  condVar_.notify_one();
+}
+
+void PalWifiTest::scanEventCallback(struct chreWifiScanEvent *event) {
+  if (event == nullptr) {
+    LOGE("Got null scan event");
+  } else {
+    {
+      chre::LockGuard<chre::Mutex> lock(mutex_);
+      scanEventList_.push_back(event);
+      numScanResultCount_ += event->resultCount;
+      lastScanEventReceived_ = (numScanResultCount_ == event->resultTotal);
+    }
+
+    condVar_.notify_one();
+  }
+}
+
+void PalWifiTest::rangingEventCallback(uint8_t errorCode,
+                                       struct chreWifiRangingEvent *event) {
+  // TODO:
+}
+
+void PalWifiTest::validateWifiScanEvent(const chreWifiScanEvent &event) {
+  if (scanParams_.has_value()) {
+    EXPECT_EQ(event.scanType, scanParams_->scanType);
+    EXPECT_GE(event.referenceTime,
+              chreGetTime() - (scanParams_->maxScanAgeMs *
+                               chre::kOneMillisecondInNanoseconds));
+    EXPECT_EQ(event.radioChainPref, scanParams_->radioChainPref);
+    EXPECT_EQ(event.eventIndex, static_cast<uint8_t>(lastEventIndex_ + 1));
+  }
+}
+
+void PalWifiTest::waitForAsyncResponseAssertSuccess(
+    chre::Nanoseconds timeoutNs) {
+  bool waitSuccess = true;
+  while (errorCode_ == CHRE_ERROR_LAST && waitSuccess) {
+    waitSuccess = condVar_.wait_for(mutex_, timeoutNs);
+  }
+  ASSERT_TRUE(waitSuccess);
+  ASSERT_EQ(errorCode_, CHRE_ERROR_NONE);
+}
+
+TEST_F(PalWifiTest, ScanAsyncTest) {
+  bool hasOnDemandScanCapability =
+      (api_->getCapabilities() & CHRE_WIFI_CAPABILITIES_ON_DEMAND_SCAN) ==
+      CHRE_WIFI_CAPABILITIES_ON_DEMAND_SCAN;
+#if PAL_IMPL_TEST_WIFI_ON_DEMAND_SCAN_REQUIRED
+  ASSERT_TRUE(hasOnDemandScanCapability);
+#else
+  if (!hasOnDemandScanCapability) {
+    GTEST_SKIP();
+  }
+#endif
+
+  // Request a WiFi scan
+  chre::LockGuard<chre::Mutex> lock(mutex_);
+
+  struct chreWifiScanParams params = {};
+  params.scanType = CHRE_WIFI_SCAN_TYPE_ACTIVE;
+  params.maxScanAgeMs = 5000;  // 5 seconds
+  params.frequencyListLen = 0;
+  params.ssidListLen = 0;
+  params.radioChainPref = CHRE_WIFI_RADIO_CHAIN_PREF_DEFAULT;
+  scanParams_ = params;
+
+  prepareForAsyncResponse();
+  ASSERT_TRUE(api_->requestScan(&scanParams_.value()));
+  waitForAsyncResponseAssertSuccess(kScanResultTimeoutNs);
+
+  // The CHRE API only poses timeout requirements on the async response. Use
+  // the same timeout to receive the scan results to avoid blocking forever.
+  bool waitSuccess = true;
+  while (!lastScanEventReceived_ && waitSuccess) {
+    waitSuccess = condVar_.wait_for(mutex_, kScanResultTimeoutNs);
+  }
+
+  for (auto *event : scanEventList_) {
+    for (uint8_t i = 0; i < event->resultCount; i++) {
+      const chreWifiScanResult &result = event->results[i];
+      logChreWifiResult(result);
+    }
+    validateWifiScanEvent(*event);
+
+    lastEventIndex_ = event->eventIndex;
+    api_->releaseScanEvent(event);
+  }
+
+  EXPECT_TRUE(lastScanEventReceived_);
+  EXPECT_GT(numScanResultCount_, 0);
+}
+
+// Note: This test only verifies that the scan monitor succeeds according
+// to the async response.
+TEST_F(PalWifiTest, ScanMonitorTest) {
+  bool hasScanMonitoringCapability =
+      (api_->getCapabilities() & CHRE_WIFI_CAPABILITIES_SCAN_MONITORING) ==
+      CHRE_WIFI_CAPABILITIES_SCAN_MONITORING;
+#if PAL_IMPL_TEST_WIFI_SCAN_MONITORING_REQUIRED
+  ASSERT_TRUE(hasScanMonitoringCapability);
+#else
+  if (!hasScanMonitoringCapability) {
+    GTEST_SKIP();
+  }
+#endif
+
+  chre::LockGuard<chre::Mutex> lock(mutex_);
+
+  prepareForAsyncResponse();
+  ASSERT_TRUE(api_->configureScanMonitor(true /* enable */));
+  waitForAsyncResponseAssertSuccess(kAsyncResultTimeoutNs);
+  ASSERT_TRUE(scanMonitorEnabled_);
+
+  prepareForAsyncResponse();
+  ASSERT_TRUE(api_->configureScanMonitor(false /* enable */));
+  waitForAsyncResponseAssertSuccess(kAsyncResultTimeoutNs);
+  ASSERT_FALSE(scanMonitorEnabled_);
+}
+
+}  // namespace wifi_pal_impl_test
diff --git a/pal/tests/wwan_test.cc b/pal/tests/src/wwan_test.cc
similarity index 100%
rename from pal/tests/wwan_test.cc
rename to pal/tests/src/wwan_test.cc
diff --git a/platform/platform.mk b/platform/platform.mk
index 2ce2891..fa469c1 100644
--- a/platform/platform.mk
+++ b/platform/platform.mk
@@ -245,10 +245,10 @@
 
 # Add in host sources to allow the executable to both be a socket server and
 # CHRE implementation.
-GOOGLE_ARM64_ANDROID_CFLAGS += -I$(ANDROID_BUILD_TOP)/system/core/base/include
+GOOGLE_ARM64_ANDROID_CFLAGS += -I$(ANDROID_BUILD_TOP)/system/libbase/include
 GOOGLE_ARM64_ANDROID_CFLAGS += -I$(ANDROID_BUILD_TOP)/system/core/libcutils/include
 GOOGLE_ARM64_ANDROID_CFLAGS += -I$(ANDROID_BUILD_TOP)/system/core/libutils/include
-GOOGLE_ARM64_ANDROID_CFLAGS += -I$(ANDROID_BUILD_TOP)/system/core/liblog/include
+GOOGLE_ARM64_ANDROID_CFLAGS += -I$(ANDROID_BUILD_TOP)/system/logging/liblog/include
 GOOGLE_ARM64_ANDROID_CFLAGS += -Ihost/common/include
 
 # Also add the linux sources to fall back to the default Linux implementation.
@@ -260,7 +260,7 @@
 # Android-specific Source Files ################################################
 
 ANDROID_CUTILS_TOP = $(ANDROID_BUILD_TOP)/system/core/libcutils
-ANDROID_LOG_TOP = $(ANDROID_BUILD_TOP)/system/core/liblog
+ANDROID_LOG_TOP = $(ANDROID_BUILD_TOP)/system/logging/liblog
 
 GOOGLE_ARM64_ANDROID_SRCS += $(ANDROID_CUTILS_TOP)/sockets_unix.cpp
 GOOGLE_ARM64_ANDROID_SRCS += $(ANDROID_CUTILS_TOP)/android_get_control_file.cpp
@@ -289,6 +289,6 @@
 
 # GoogleTest Source Files ######################################################
 
-GOOGLETEST_SRCS += platform/linux/assert.cc
-GOOGLETEST_SRCS += platform/linux/audio_source.cc
-GOOGLETEST_SRCS += platform/linux/platform_audio.cc
+GOOGLETEST_COMMON_SRCS += platform/linux/assert.cc
+GOOGLETEST_COMMON_SRCS += platform/linux/audio_source.cc
+GOOGLETEST_COMMON_SRCS += platform/linux/platform_audio.cc
diff --git a/run_pal_impl_tests.sh b/run_pal_impl_tests.sh
new file mode 100755
index 0000000..4b0daed
--- /dev/null
+++ b/run_pal_impl_tests.sh
@@ -0,0 +1,17 @@
+#!/bin/bash
+
+# Quit if any command produces an error.
+set -e
+
+# Build and run the CHRE unit test binary.
+JOB_COUNT=$((`grep -c ^processor /proc/cpuinfo`))
+
+# Export the variant Makefile.
+export CHRE_VARIANT_MK_INCLUDES="$CHRE_VARIANT_MK_INCLUDES \
+  variant/googletest/variant.mk"
+
+export RUN_PAL_IMPL_TESTS=true
+
+make clean
+make google_x86_googletest_debug -j$JOB_COUNT
+./out/google_x86_googletest_debug/libchre $1