DoIt 测试文章

use std::collections::{BTreeMap, HashMap};
const DEFAULT_TTL_SECS: u64 = 3600;
#[derive(Clone, Debug)]
struct User {
    id: u64,
    name: String,
    scopes: Vec<String>,
}
#[derive(Clone, Debug)]
struct TokenRecord {
    access_token: String,
    ttl_secs: u64,
    user: User,
}
struct TokenCache {
    store: HashMap<u64, TokenRecord>,
}
impl TokenCache {
    fn new() -> Self {
        Self { store: HashMap::new() }
    }
    fn put(&mut self, user: User, access_token: &str, scopes: &str) {
        let user_id = user.id;
        let scopes = parse_scopes(scopes);
        let record = TokenRecord {
            access_token: access_token.to_string(),
            ttl_secs: DEFAULT_TTL_SECS,
            user: User { scopes, ..user },
        };
        self.store.insert(user_id, record);
    }
    fn has_scope(&self, user_id: u64, scope: &str) -> bool {
        self.store.get(&user_id)
            .map(|record| record.user.scopes.iter().any(|value| value == scope))
            .unwrap_or(false)
    }
    fn names(&self) -> Vec<String> {
        let mut names = self.store.values().map(|record| record.user.name.clone()).collect::<Vec<_>>();
        names.sort();
        names
    }
}
fn parse_scopes(input: &str) -> Vec<String> {
    input.split(',').map(str::trim)
        .filter(|value| !value.is_empty())
        .map(ToString::to_string)
        .collect()
}
fn exchange_code(code: &str) -> Result<String, String> {
    if code.len() < 8 {
        return Err("authorization code is too short".into());
    }
    Ok(format!("token_{}", &code[..8]))
}
fn fetch_profile(token: &str) -> Result<User, String> {
    if !token.starts_with("token_") {
        return Err("invalid token format".into());
    }
    Ok(User {
        id: 42,
        name: "demo-user".into(),
        scopes: vec!["openid".into(), "email".into()],
    })
}
fn build_scope_index(cache: &TokenCache) -> BTreeMap<String, usize> {
    let mut stats = BTreeMap::new();
    for record in cache.store.values() {
        for scope in &record.user.scopes {
            *stats.entry(scope.clone()).or_insert(0) += 1;
        }
    }
    stats
}
fn seed_cache() -> TokenCache {
    let mut cache = TokenCache::new();
    cache.put(User { id: 1, name: "alice".into(), scopes: Vec::new() }, "token_alice", "openid,email,profile");
    cache.put(User { id: 2, name: "bob".into(), scopes: Vec::new() }, "token_bob__", "openid");
    cache.put(User { id: 3, name: "carol".into(), scopes: Vec::new() }, "token_carol", "openid,calendar");
    cache
}
fn main() -> Result<(), String> {
    let cache = seed_cache();
    println!("known users: {}", cache.names().join(", "));
    println!("carol has calendar: {}", cache.has_scope(3, "calendar"));
    println!("bob has drive: {}", cache.has_scope(2, "drive"));
    for (scope, count) in build_scope_index(&cache) {
        println!("{scope}: {count}");
    }
    let token = exchange_code("abcd1234xyz")?;
    let profile = fetch_profile(&token)?;
    println!("signed in: {}", profile.name);
    println!("granted scopes: {}", profile.scopes.join(", "));
    if let Some(record) = cache.store.get(&1) {
        println!("alice token preview: {}", &record.access_token[..10]);
    }
    if let Some(record) = cache.store.get(&1) {
        println!("alice ttl: {}", record.ttl_secs);
    }
    Ok(())
}

package main
import (
	"context"
	"encoding/json"
	"fmt"
	"log"
	"net/http"
	"sync"
	"time"
)
type Session struct {
	UserID      string    `json:"user_id"`
	AccessToken string    `json:"access_token"`
	ExpiresAt   time.Time `json:"expires_at"`
}
type Store struct {
	mu       sync.RWMutex
	sessions map[string]Session
}
func NewStore() *Store {
	return &Store{sessions: map[string]Session{}}
}
func (s *Store) Save(id string, session Session) {
	s.mu.Lock()
	defer s.mu.Unlock()
	s.sessions[id] = session
}
func (s *Store) Get(id string) (Session, bool) {
	s.mu.RLock()
	defer s.mu.RUnlock()
	session, ok := s.sessions[id]
	return session, ok
}
func exchangeCode(ctx context.Context, code string) (string, error) {
	_ = ctx
	if len(code) < 8 {
		return "", fmt.Errorf("authorization code is too short")
	}
	return "token_" + code[:8], nil
}

func fetchProfile(ctx context.Context, token string) (string, error) {
	_ = ctx
	if token == "" {
		return "", fmt.Errorf("missing token")
	}
	return "google-user-42", nil
}
func callbackHandler(store *Store) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		ctx := r.Context()
		code := r.URL.Query().Get("code")
		state := r.URL.Query().Get("state")
		if code == "" || state == "" {
			http.Error(w, "missing code or state", http.StatusBadRequest)
			return
		}
		token, err := exchangeCode(ctx, code)
		if err != nil {
			http.Error(w, err.Error(), http.StatusBadGateway)
			return
		}
		userID, err := fetchProfile(ctx, token)
		if err != nil {
			http.Error(w, err.Error(), http.StatusBadGateway)
			return
		}
		session := Session{
			UserID:      userID,
			AccessToken: token,
			ExpiresAt:   time.Now().Add(1 * time.Hour),
		}
		store.Save(state, session)
		w.Header().Set("Content-Type", "application/json")
		_ = json.NewEncoder(w).Encode(session)
	}
}
func healthHandler(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/plain; charset=utf-8")
	_, _ = w.Write([]byte("ok\n"))
}
func main() {
	store := NewStore()
	mux := http.NewServeMux()
	mux.Handle("/oauth/google/callback", callbackHandler(store))
	mux.HandleFunc("/healthz", healthHandler)
	server := &http.Server{
		Addr:              ":8080",
		Handler:           mux,
		ReadHeaderTimeout: 3 * time.Second,
	}
	log.Println("listening on http://127.0.0.1:8080")
	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
		log.Fatal(err)
	}
}
// Long-block check: line numbers should still render clearly.
// Long-block check: syntax highlighting should remain stable.
// Long-block check: default collapsed state should still expand.
// End of Go sample.

#include <iostream>
#include <list>
#include <optional>
#include <string>
#include <unordered_map>
#include <vector>
struct Entry {
    std::string key;
    int value;
};
class LruCache {
public:
    explicit LruCache(std::size_t capacity) : capacity_(capacity) {}
    void put(const std::string& key, int value) {
        auto it = index_.find(key);
        if (it != index_.end()) {
            it->second->value = value;
            touch(it->second);
            return;
        }
        if (items_.size() == capacity_) {
            evict();
        }
        items_.push_front(Entry{key, value});
        index_[key] = items_.begin();
    }
    std::optional<int> get(const std::string& key) {
        auto it = index_.find(key);
        if (it == index_.end()) {
            return std::nullopt;
        }
        touch(it->second);
        return it->second->value;
    }
    bool contains(const std::string& key) const {
        return index_.find(key) != index_.end();
    }
    void dump() const {
        for (const auto& item : items_) {
            std::cout << item.key << ":" << item.value << "\n";
        }
    }
private:
    using List = std::list<Entry>;
    using Iter = List::iterator;
    void touch(Iter it) {
        if (it == items_.begin()) {
            return;
        }
        items_.splice(items_.begin(), items_, it);
    }
    void evict() {
        const auto& last = items_.back();
        index_.erase(last.key);
        items_.pop_back();
    }

    std::size_t capacity_;
    List items_;
    std::unordered_map<std::string, Iter> index_;
};

std::vector<std::string> scenario() {
    return {"auth_code", "access_token", "refresh_token", "profile"};
}

int score_key(const std::string& key) {
    int sum = 0;
    for (char ch : key) {
        sum += static_cast<int>(ch);
    }
    return sum % 100;
}

int main() {
    LruCache cache(3);
    for (const auto& key : scenario()) {
        cache.put(key, score_key(key));
    }
    cache.put("id_token", 88);
    if (auto value = cache.get("profile")) {
        std::cout << "profile=" << *value << "\n";
    } else {
        std::cout << "profile was evicted\n";
    }
    if (auto value = cache.get("id_token")) {
        std::cout << "id_token=" << *value << "\n";
    }
    cache.put("user_info", 77);
    cache.put("session", 66);
    std::cout << "contains access_token=" << cache.contains("access_token") << "\n";
    std::cout << "contains session=" << cache.contains("session") << "\n";
    cache.dump();
    return 0;
}
// The following lines intentionally keep the sample long for renderer checks.
// They help verify long block folding in the Hugo theme.
// They also make line number gutters easier to inspect visually.
// For production C++, prefer stronger error handling and tests.
// End of C++ sample.