Fix lint issues: remove trailing whitespace and reformat lines

Co-authored-by: bbockelm <1093447+bbockelm@users.noreply.github.com>

Author: Copilot

src/scitokens_internal.cpp

@@ -42,32 +42,34 @@ constexpr size_t MAX_ISSUER_MUTEXES = 1000;
 // Get or create a mutex for a specific issuer
 std::shared_ptr<std::mutex> get_issuer_mutex(const std::string &issuer) {
     std::lock_guard<std::mutex> guard(issuer_mutex_map_lock);
-    
+
     auto it = issuer_mutexes.find(issuer);
     if (it != issuer_mutexes.end()) {
         return it->second;
     }
-    
+
     // Prevent resource exhaustion: limit the number of cached mutexes
     if (issuer_mutexes.size() >= MAX_ISSUER_MUTEXES) {
         // Remove mutexes that are no longer in use
         // Since we hold issuer_mutex_map_lock, no other thread can acquire
         // a reference to these mutexes, making this check safe
-        for (auto iter = issuer_mutexes.begin(); iter != issuer_mutexes.end(); ) {
+        for (auto iter = issuer_mutexes.begin();
+             iter != issuer_mutexes.end();) {
             if (iter->second.use_count() == 1) {
                 // Only we hold a reference, safe to remove
                 iter = issuer_mutexes.erase(iter);
             } else {
                 ++iter;
             }
         }
-        
+
         // If still at capacity after cleanup, fail rather than unbounded growth
         if (issuer_mutexes.size() >= MAX_ISSUER_MUTEXES) {
-            throw std::runtime_error("Too many concurrent issuers - resource exhaustion prevented");
+            throw std::runtime_error(
+                "Too many concurrent issuers - resource exhaustion prevented");
         }
     }
-    
+
     auto mutex_ptr = std::make_shared<std::mutex>();
     issuer_mutexes[issuer] = mutex_ptr;
     return mutex_ptr;
@@ -872,8 +874,9 @@ Validator::get_public_key_pem(const std::string &issuer, const std::string &kid,
         // Use per-issuer lock to prevent thundering herd for new issuers
         auto issuer_mutex = get_issuer_mutex(issuer);
         std::lock_guard<std::mutex> lock(*issuer_mutex);
-        
-        // Check again if keys are now in DB (another thread may have fetched them)
+
+        // Check again if keys are now in DB (another thread may have fetched
+        // them)
         if (get_public_keys_from_db(issuer, now, result->m_keys,
                                     result->m_next_update)) {
             // Keys are now available, use them

test/main.cpp

@@ -504,7 +504,7 @@ TEST_F(SerializeTest, ExplicitTime) {
 
 TEST_F(SerializeTest, GetExpirationErrorHandling) {
     char *err_msg = nullptr;
-    
+
     // Test NULL token handling
     long long expiry;
     auto rv = scitoken_get_expiration(nullptr, &expiry, &err_msg);
@@ -513,27 +513,28 @@ TEST_F(SerializeTest, GetExpirationErrorHandling) {
     EXPECT_STREQ(err_msg, "Token cannot be NULL");
     free(err_msg);
     err_msg = nullptr;
-    
-    // Test NULL expiry parameter handling  
+
+    // Test NULL expiry parameter handling
     rv = scitoken_get_expiration(m_token.get(), nullptr, &err_msg);
     ASSERT_FALSE(rv == 0);
     ASSERT_TRUE(err_msg != nullptr);
     EXPECT_STREQ(err_msg, "Expiry output parameter cannot be NULL");
     free(err_msg);
     err_msg = nullptr;
-    
+
     // Test normal operation works
     char *token_value = nullptr;
     rv = scitoken_serialize(m_token.get(), &token_value, &err_msg);
     ASSERT_TRUE(rv == 0) << err_msg;
-    
-    rv = scitoken_deserialize_v2(token_value, m_read_token.get(), nullptr, &err_msg);
+
+    rv = scitoken_deserialize_v2(token_value, m_read_token.get(), nullptr,
+                                 &err_msg);
     ASSERT_TRUE(rv == 0) << err_msg;
-    
+
     rv = scitoken_get_expiration(m_read_token.get(), &expiry, &err_msg);
     ASSERT_TRUE(rv == 0) << err_msg;
     ASSERT_TRUE(expiry > 0);
-    
+
     free(token_value);
 }
 
@@ -725,7 +726,8 @@ TEST_F(KeycacheTest, SetGetTest) {
 TEST_F(KeycacheTest, SetGetConfiguredCacheHome) {
     // Set cache home
     char cache_path[FILENAME_MAX];
-    ASSERT_TRUE(getcwd(cache_path, sizeof(cache_path)) != nullptr); // Side effect gets cwd
+    ASSERT_TRUE(getcwd(cache_path, sizeof(cache_path)) !=
+                nullptr); // Side effect gets cwd
     char *err_msg = nullptr;
     std::string key = "keycache.cache_home";
 
@@ -944,30 +946,31 @@ TEST_F(IssuerSecurityTest, SpecialCharacterIssuer) {
 // Test for thundering herd prevention with per-issuer locks
 TEST_F(IssuerSecurityTest, ThunderingHerdPrevention) {
     char *err_msg = nullptr;
-    
+
     // Create tokens for a new issuer and pre-populate the cache
     std::string test_issuer = "https://thundering-herd-test.example.org/gtest";
-    
+
     auto rv = scitoken_set_claim_string(m_token.get(), "iss",
                                         test_issuer.c_str(), &err_msg);
     ASSERT_TRUE(rv == 0) << err_msg;
-    
+
     // Store public key for this issuer in the cache
     rv = scitoken_store_public_ec_key(test_issuer.c_str(), "1", ec_public,
                                       &err_msg);
     ASSERT_TRUE(rv == 0) << err_msg;
-    
+
     char *token_value = nullptr;
     rv = scitoken_serialize(m_token.get(), &token_value, &err_msg);
     ASSERT_TRUE(rv == 0) << err_msg;
     std::unique_ptr<char, decltype(&free)> token_value_ptr(token_value, free);
-    
-    // Successfully deserialize - the per-issuer lock should prevent thundering herd
-    // Since we pre-populated the cache, this should succeed without network access
+
+    // Successfully deserialize - the per-issuer lock should prevent thundering
+    // herd Since we pre-populated the cache, this should succeed without
+    // network access
     rv = scitoken_deserialize_v2(token_value, m_read_token.get(), nullptr,
                                  &err_msg);
     ASSERT_TRUE(rv == 0) << err_msg;
-    
+
     // Verify the issuer claim
     char *value;
     rv = scitoken_get_claim_string(m_read_token.get(), "iss", &value, &err_msg);