import org.junit.jupiter.api.*;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.CsvSource;
import org.junit.jupiter.params.provider.ValueSource;
import org.junit.jupiter.api.parallel.Execution;
import org.junit.jupiter.api.parallel.ExecutionMode;

import static org.junit.jupiter.api.Assertions.*;

@DisplayName("订单金额计算器")
class OrderAmountCalculatorTest {

    private OrderAmountCalculator calculator;

    // 每个测试方法前执行（默认 PER_METHOD 生命周期）
    @BeforeEach
    void setUp() {
        calculator = new OrderAmountCalculator();
    }

    @AfterEach
    void tearDown() {
        // 清理资源，例如还原系统属性、清理临时文件
    }

    // 所有方法共享一次，适合昂贵资源（如启动容器）
    @BeforeAll
    static void initAll() {
        System.setProperty("discount.enabled", "true");
    }

    @Test
    @DisplayName("满 100 减 10：边界值应命中优惠")
    void shouldApplyDiscountWhenAmountEqualsThreshold() {
        // given - 准备输入与前置条件
        List<OrderItem> items = List.of(new OrderItem("A", 1, new BigDecimal("100.00")));

        // when - 执行被测行为
        BigDecimal actual = calculator.calculate(items);

        // then - 断言结果
        assertEquals(0, new BigDecimal("90.00").compareTo(actual));
    }

    // 参数化：一次声明多组输入，避免复制粘贴多个测试方法
    @ParameterizedTest(name = "金额 {0} 期望优惠后 {1}")
    @CsvSource({
        "100.00, 90.00",
        "99.99,  99.99",
        "200.00, 180.00"
    })
    void shouldCalculateDiscount(String amount, String expected) {
        List<OrderItem> items = List.of(new OrderItem("A", 1, new BigDecimal(amount)));
        assertEquals(0, new BigDecimal(expected).compareTo(calculator.calculate(items)));
    }

    // 断言异常：用 assertThrows 拿到异常对象，可以进一步断言 message
    @ParameterizedTest
    @ValueSource(strings = {"", " "})
    void shouldRejectBlankSku(String sku) {
        IllegalArgumentException ex = assertThrows(
            IllegalArgumentException.class,
            () -> new OrderItem(sku, 1, BigDecimal.ONE));
        assertTrue(ex.getMessage().contains("sku"));
    }

    // 超时断言：防止性能回归（注意：不要用 assertTimeoutPreemptively 跑共享资源的代码）
    @Test
    void shouldFinishFast() {
        assertTimeout(java.time.Duration.ofMillis(200),
            () -> calculator.calculate(List.of()));
    }

    // 嵌套测试：把同一场景下的多个变体组织在一起，语义更清晰
    @Nested
    @DisplayName("VIP 用户场景")
    class VipScenario {

        @Test
        @DisplayName("VIP 折扣叠加满减")
        void shouldStackVipDiscount() {
            // 复用外层 calculator，但语义上属于独立分组
            assertDoesNotThrow(() -> calculator.calculate(List.of()));
        }
    }
}

import org.mockito.*;
import static org.mockito.Mockito.*;
import static org.mockito.ArgumentMatchers.*;

@ExtendWith(MockitoExtension.class) // JUnit5 集成 Mockito 的官方扩展
class OrderServiceTest {

    @Mock
    private OrderRepository repository;      // 完全替身：默认返回 null / 空集合
    @Mock
    private RiskClient riskClient;           // 外部服务
    @Spy
    private AmountCalculator realCalculator = new AmountCalculator(); // 走真实逻辑
    @InjectMocks
    private OrderService orderService;       // 自动把上面的 mock 注入进来

    @Captor
    private ArgumentCaptor<Order> orderCaptor;

    @Test
    void shouldRejectOrderWhenRiskServiceSaysNo() {
        // 打桩：指定输入 → 返回值
        when(riskClient.check(anyString())).thenReturn(RiskResult.REJECT);
        // 连续调用返回不同值（模拟重试场景）
        when(repository.findById(100L))
            .thenReturn(Optional.of(new Order(100L)))
            .thenReturn(Optional.empty());

        assertThrows(RiskRejectedException.class, () -> orderService.submit(100L));

        // 验证行为：riskClient 被调用了一次，且参数被捕获
        verify(riskClient, times(1)).check(eq("user-1"));
        // 验证"从未调用"——比验证"调用了"更有价值
        verify(repository, never()).save(any(Order.class));
    }

    @Test
    void shouldSaveOrderWithCalculatedAmount() {
        when(riskClient.check(anyString())).thenReturn(RiskResult.PASS);

        orderService.submit(100L);

        // 捕获真实入参，断言其内部结构
        verify(repository).save(orderCaptor.capture());
        Order saved = orderCaptor.getValue();
        assertEquals(OrderStatus.CREATED, saved.getStatus());
    }

    @Test
    void shouldRollbackOnRepositoryFailure() {
        when(riskClient.check(anyString())).thenReturn(RiskResult.PASS);
        // 模拟异常：thenThrow 用于验证异常分支的补偿逻辑
        doThrow(new DataAccessException("db down")).when(repository).save(any());

        assertThrows(DataAccessException.class, () -> orderService.submit(100L));
        // 断言补偿动作确实发生了（例如发了告警）
        verify(riskClient).reportFailure(anyString());
    }
}

@Testcontainers
@DataJpaTest // Spring Boot 测试切片：只加载 JPA 相关的 Bean，不启动整个容器
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE) // 别替换成 H2
class OrderRepositoryIT {

    // 静态字段：所有测试方法共享一个容器（否则每个方法起一个，慢到无法接受）
    @Container
    static MySQLContainer<?> mysql =
        new MySQLContainer<>("mysql:8.4")
            .withDatabaseName("order")
            .withUsername("test")
            .withPassword("test")
            .withReuse(true); // 需要 ~/.testcontainers.properties 开启 reuse

    @DynamicPropertySource // 把容器地址动态注入 Spring Environment
    static void datasourceProps(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url", mysql::getJdbcUrl);
        registry.add("spring.datasource.username", mysql::getUsername);
        registry.add("spring.datasource.password", mysql::getPassword);
    }

    @Autowired
    private OrderRepository repository;

    @Test
    void shouldFindByStatus() {
        repository.save(new Order("A-1", OrderStatus.CREATED));
        // TestEntityManager 让你可以精确控制 flush/clear，验证真实落库行为
        assertThat(repository.findByStatus(OrderStatus.CREATED)).hasSize(1);
    }
}

// Web 层切片：只加载 Controller + MVC 基础设施，Service 用 @MockBean 替掉
@WebMvcTest(OrderController.class)
class OrderControllerTest {

    @Autowired
    private MockMvc mockMvc;
    @MockBean
    private OrderService orderService; // 不加载真实 Service 及其依赖链

    @Test
    void shouldReturnOrderJson() throws Exception {
        when(orderService.getOrder(1L)).thenReturn(new OrderDTO(1L, "A-1", OrderStatus.CREATED));

        mockMvc.perform(get("/orders/{id}", 1L).accept(MediaType.APPLICATION_JSON))
               .andExpect(status().isOk())
               .andExpect(jsonPath("$.orderNo").value("A-1"))
               .andExpect(jsonPath("$.status").value("CREATED"));
    }

    @Test
    void shouldReturn400WhenIdInvalid() throws Exception {
        mockMvc.perform(get("/orders/{id}", "abc"))
               .andExpect(status().isBadRequest());
    }
}

// 错误示范：字符串拼接 + 不必要的开销
log.debug("order detail: " + JSON.toJSONString(order));   // 即使 DEBUG 关闭，toJSONString 也执行了
log.info("user " + userId + " bought " + itemId);          // 每次都创建新 String

// 正确示范：占位符 + 惰性求值
log.debug("order detail: {}", order);                      // 只在启用时才调用 toString()
log.info("user {} bought {}", userId, itemId);

// 需要计算开销大的内容时，用 isDebugEnabled() 守卫（或 Java 8+ 的 Supplier）
if (log.isDebugEnabled()) {
    log.debug("big payload: {}", JSON.toJSONString(order));
}
// SLF4J 2.x 支持 Fluent API 与 Supplier，避免显式 if
log.atDebug().addArgument(() -> JSON.toJSONString(order)).log("payload: {}");

@Component
public class TraceIdFilter extends OncePerRequestFilter {

    @Override
    protected void doFilterInternal(HttpServletRequest request,
                                    HttpServletResponse response,
                                    FilterChain chain) throws ServletException, IOException {
        // 优先透传上游链路 ID（网关/SkyWalking/上游服务），没有则生成
        String traceId = Optional.ofNullable(request.getHeader("X-Trace-Id"))
                                 .filter(StringUtils::hasText)
                                 .orElseGet(() -> UUID.randomUUID().toString().replace("-", ""));
        MDC.put("traceId", traceId);
        response.setHeader("X-Trace-Id", traceId);
        try {
            long start = System.nanoTime();
            chain.doFilter(request, response);
            // 统一记录访问日志：URI、状态、耗时
            log.info("{} {} status={} cost={}ms",
                     request.getMethod(), request.getRequestURI(),
                     response.getStatus(), (System.nanoTime() - start) / 1_000_000);
        } finally {
            MDC.remove("traceId"); // 必须清理：线程来自线程池，不清理会导致 traceId 串号
        }
    }
}

// 方案 1：提交任务时拷贝上下文，任务内还原
public static Runnable wrap(Runnable task) {
    Map<String, String> ctx = MDC.getCopyOfContextMap();     // 在主线程捕获
    return () -> {
        if (ctx != null) MDC.setContextMap(ctx);
        try {
            task.run();
        } finally {
            MDC.clear();                                      // 用完清掉，避免污染池中线程
        }
    };
}

// 方案 2（Spring）：给线程池设置 TaskDecorator，对所有 @Async 生效
@Bean
public Executor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(8);
    executor.setMaxPoolSize(32);
    executor.setQueueCapacity(2000);            // 必须有界
    executor.setTaskDecorator(r -> {
        Map<String, String> ctx = MDC.getCopyOfContextMap();
        return () -> {
            if (ctx != null) MDC.setContextMap(ctx);
            try { r.run(); } finally { MDC.clear(); }
        };
    });
    executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
    executor.initialize();
    return executor;
}

// 一个典型的"错误基准"：这段代码测出来的结果几乎没有任何意义
long start = System.currentTimeMillis();
for (int i = 0; i < 100_000; i++) {
    String s = "" + i;          // 结果从未被使用
}
System.out.println(System.currentTimeMillis() - start);

package com.example.bench;

import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.infra.Blackhole;
import java.util.concurrent.TimeUnit;

@BenchmarkMode(Mode.AverageTime)          // 关注单次操作耗时
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@Warmup(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS)      // 预热：让 JIT 完成分层编译
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) // 正式测量
@Fork(2)             // 跑 2 个独立 JVM，避免单次编译偶然性
@State(Scope.Benchmark)
public class StringConcatBenchmark {

    @Param({"10", "100", "1000"})  // 三种规模，跑出 3×2 的结果矩阵
    private int count;

    // 关键：数据从 @State 字段读取而非方法内常量，
    // 否则 JIT 可能做常量折叠，把整段逻辑优化成一次赋值
    private String[] parts;

    @Setup(Level.Trial)
    public void setup() {
        parts = new String[count];
        for (int i = 0; i < count; i++) {
            parts[i] = "item-" + i;
        }
    }

    @Benchmark
    public String plusConcat() {
        String result = "";
        for (String p : parts) {
            result = result + p;   // 每次新建 StringBuilder + 新建 String：O(n^2)
        }
        return result;             // 返回给 JMH，制造真实副作用，防止死代码消除
    }

    @Benchmark
    public String builderConcat() {
        StringBuilder sb = new StringBuilder();
        for (String p : parts) {
            sb.append(p);
        }
        return sb.toString();
    }

    @Benchmark
    public String builderWithCapacity() {
        // 预设容量：避免 StringBuilder 内部 char[] 多次 Arrays.copyOf 扩容
        StringBuilder sb = new StringBuilder(estimateCapacity());
        for (String p : parts) {
            sb.append(p);
        }
        return sb.toString();
    }

    // 只消费不返回时用 Blackhole，JIT 无法推断其无副作用
    @Benchmark
    public void blackholeDemo(Blackhole bh) {
        StringBuilder sb = new StringBuilder();
        for (String p : parts) sb.append(p);
        bh.consume(sb.toString());
    }

    private int estimateCapacity() {
        int len = 0;
        for (String p : parts) len += p.length();
        return len;
    }
}

// 伪共享：两个独立的 AtomicLong 若相邻，会落在同一 64 字节缓存行，
// 两个线程分别修改它们时，会互相使对方的缓存行失效（MESI 协议），性能甚至低于单线程。
public class CounterWithPadding {
    // JDK 8：sun.misc.Contended
    // JDK 9+：jdk.internal.vm.annotation.Contended（需 -XX:-RestrictContended 或 --add-exports）
    @jdk.internal.vm.annotation.Contended
    private volatile long valueA;
    @jdk.internal.vm.annotation.Contended
    private volatile long valueB;

    // 不使用注解时的手工填充方案（JDK 8 常见写法）
    public static class PaddedAtomicLong extends java.util.concurrent.atomic.AtomicLong {
        // 对象头(12~16B) + value(8B) + 前后各 7 个 long 填充，确保独占缓存行
        private volatile long p1, p2, p3, p4, p5, p6, p7 = 0L;
        public long sumPaddingToPreventOptimization() {
            return p1 + p2 + p3 + p4 + p5 + p6 + p7;
        }
    }
}
// 运行对照实验：
// java -XX:-RestrictContended -jar benchmarks.jar FalseSharingBenchmark

// 优化前：循环查库 + 日志全量序列化 + 每次 new ObjectMapper
for (Order order : orders) {
    List<OrderItem> items = itemMapper.selectByOrderId(order.getId()); // N+1
    order.setItems(items);
    log.debug("detail: {}", JSON.toJSONString(order));                  // 无条件序列化
}
String json = new ObjectMapper().writeValueAsString(result);            // 每次新建

// 优化后：批量查询 + 占位符惰性输出 + 静态单例 + 索引
List<Long> ids = orders.stream().map(Order::getId).toList();
Map<Long, List<OrderItem>> itemsByOrder = itemMapper.selectByOrderIds(ids) // 一次 IN 查询
        .stream().collect(Collectors.groupingBy(OrderItem::getOrderId));   // 内存分组
for (Order order : orders) {
    order.setItems(itemsByOrder.getOrDefault(order.getId(), List.of()));
    log.debug("orderId={}, itemCount={}", order.getId(), order.getItems().size()); // 只输出标量
}
String json = JsonHolder.MAPPER.writeValueAsString(result);  // 静态单例