package test

const (
	APITypeHi = iota + 1
	APITypeHello
)

type Greeting interface {
	Say(msg string) string
}

func NewGreeting(t int) Greeting {
	if t == APITypeHi {
		return &Hi{}
	} else if t == APITypeHello {
		return &Hello{}
	}
	return nil
}

type Hi struct{}

func (h *Hi) Say(msg string) string {
	return "Hi! " + msg
}

type Hello struct{}

func (h *Hello) Say(msg string) string {
	return "Hello! " + msg
}

package test

import "testing"

func TestGreeting(t *testing.T) {
	tests := []struct {
		name     string
		apiType  int
		msg      string
		expected string
	}{
		{"HiType", APITypeHi, "2026", "Hi! 2026"},
		{"HelloType", APITypeHello, "2026", "Hello! 2026"},
		{"NilType", 999, "2026", ""},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			g := NewGreeting(tt.apiType)
			if g == nil {
				if tt.expected != "" {
					t.Errorf("NewGreeting(%d) returned nil, expected non-nil", tt.apiType)
				}
				return
			}

			out := g.Say(tt.msg)
			if out != tt.expected {
				t.Errorf("Say() = %q, want %q", out, tt.expected)
			}
		})
	}
}

package test

// Operator 接口
type Operator interface {
	SetA(int)
	SetB(int)
	Result() int
}

// 工厂接口
type OperatorFactory interface {
	Create() Operator
}

// OperatorBase 提供公共字段与方法
type OperatorBase struct {
	a, b int
}

func (o *OperatorBase) SetA(a int) { o.a = a }
func (o *OperatorBase) SetB(b int) { o.b = b }

// PlusOperator
type PlusOperator struct{ *OperatorBase }

func (p *PlusOperator) Result() int { return p.a + p.b }

// PlusOperatorFactory
type PlusOperatorFactory struct{}

func (PlusOperatorFactory) Create() Operator {
	return &PlusOperator{&OperatorBase{}}
}

// MinusOperator
type MinusOperator struct{ *OperatorBase }

func (m *MinusOperator) Result() int { return m.a - m.b }

// MinusOperatorFactory
type MinusOperatorFactory struct{}

func (MinusOperatorFactory) Create() Operator {
	return &MinusOperator{&OperatorBase{}}
}

package test

import "testing"

func TestOperatorFactory(t *testing.T) {
	tests := []struct {
		name     string
		factory  OperatorFactory
		a, b     int
		expected int
	}{
		{"Plus", &PlusOperatorFactory{}, 1001, 10, 1011},
		{"Minus", &MinusOperatorFactory{}, 1001, 10, 991},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			op := tt.factory.Create()
			op.SetA(tt.a)
			op.SetB(tt.b)
			if got := op.Result(); got != tt.expected {
				t.Fatalf("expected %v, got %v", tt.expected, got)
			}
		})
	}
}

package test

// OrderMainDAO 为订单主记录
type OrderMainDAO interface {
	SaveOrderMain() string
}

// OrderDetailDAO 为订单详情纪录
type OrderDetailDAO interface {
	SaveOrderDetail() string
}

// DAOFactory DAO 抽象工厂接口
type DAOFactory interface {
	CreateOrderMainDAO() OrderMainDAO
	CreateOrderDetailDAO() OrderDetailDAO
}

// ------------------ RDB 实现 ------------------

type RDBMainDAO struct{}

func (*RDBMainDAO) SaveOrderMain() string {
	return "rdb main save"
}

type RDBDetailDAO struct{}

func (*RDBDetailDAO) SaveOrderDetail() string {
	return "rdb detail save"
}

type RDBDAOFactory struct{}

func (*RDBDAOFactory) CreateOrderMainDAO() OrderMainDAO {
	return &RDBMainDAO{}
}

func (*RDBDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {
	return &RDBDetailDAO{}
}

// ------------------ XML 实现 ------------------

type XMLMainDAO struct{}

func (*XMLMainDAO) SaveOrderMain() string {
	return "xml main save"
}

type XMLDetailDAO struct{}

func (*XMLDetailDAO) SaveOrderDetail() string {
	return "xml detail save"
}

type XMLDAOFactory struct{}

func (*XMLDAOFactory) CreateOrderMainDAO() OrderMainDAO {
	return &XMLMainDAO{}
}

func (*XMLDAOFactory) CreateOrderDetailDAO() OrderDetailDAO {
	return &XMLDetailDAO{}
}

package test

import "testing"

// GetMainAndDetail 调用工厂生成 DAO 并返回结果
func GetMainAndDetail(factory DAOFactory) (mainResult, detailResult string) {
	mainResult = factory.CreateOrderMainDAO().SaveOrderMain()
	detailResult = factory.CreateOrderDetailDAO().SaveOrderDetail()
	return
}

func TestAbstractFactory(t *testing.T) {
	tests := []struct {
		name           string
		factory        DAOFactory
		expectedMain   string
		expectedDetail string
	}{
		{"RDBFactory", &RDBDAOFactory{}, "rdb main save", "rdb detail save"},
		{"XMLFactory", &XMLDAOFactory{}, "xml main save", "xml detail save"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			mainResult, detailResult := GetMainAndDetail(tt.factory)
			if mainResult != tt.expectedMain {
				t.Errorf("mainResult = %q, want %q", mainResult, tt.expectedMain)
			}
			if detailResult != tt.expectedDetail {
				t.Errorf("detailResult = %q, want %q", detailResult, tt.expectedDetail)
			}
		})
	}
}

package test

import "sync"

type Singleton interface {
	Foo()
}

type singleton struct{}

func (s *singleton) Foo() {}

var (
	once     sync.Once
	instance Singleton
)

func GetSingleton() Singleton {
	once.Do(func() {
		instance = &singleton{}
	})
	return instance
}

package test

import (
	"sync"
	"testing"
)

const goroutineCount = 1000

// 单线程测试
func TestSingletonSingleThread(t *testing.T) {
	a := GetSingleton()
	b := GetSingleton()
	if a != b {
		t.Fatalf("Singleton failed: a != b")
	}
}

// 并发测试
func TestSingletonConcurrent(t *testing.T) {
	start := make(chan struct{})
	instances := [goroutineCount]Singleton{}
	wg := sync.WaitGroup{}
	wg.Add(goroutineCount)

	for i := 0; i < goroutineCount; i++ {
		go func(idx int) {
			<-start
			instances[idx] = GetSingleton()
			wg.Done()
		}(i)
	}

	// 同时启动所有 goroutine
	close(start)
	wg.Wait()

	// 验证所有实例都相等
	for i := 0; i < goroutineCount-1; i++ {
		if instances[i] != instances[i+1] {
			t.Fatalf("Singleton failed: instances[%d] != instances[%d]", i, i+1)
		}
	}
}

package test

// Builder 是生成器接口
type Builder interface {
	Part1()
	Part2()
	Part3()
}

// Director 构建指挥者
type Director struct {
	builder Builder
}

// NewDirector ...
func NewDirector(builder Builder) *Director {
	return &Director{builder: builder}
}

// Construct 构建产品
func (d *Director) Construct() {
	d.builder.Part1()
	d.builder.Part2()
	d.builder.Part3()
}

// ---------------- Builder1 ----------------

type Builder1 struct {
	result string
}

func (b *Builder1) Part1()            { b.result += "1" }
func (b *Builder1) Part2()            { b.result += "2" }
func (b *Builder1) Part3()            { b.result += "3" }
func (b *Builder1) GetResult() string { return b.result }

// ---------------- Builder2 ----------------

type Builder2 struct {
	result int
}

func (b *Builder2) Part1()         { b.result += 1 }
func (b *Builder2) Part2()         { b.result += 2 }
func (b *Builder2) Part3()         { b.result += 3 }
func (b *Builder2) GetResult() int { return b.result }

package test

import "testing"

func TestBuilder(t *testing.T) {
	tests := []struct {
		name     string
		builder  Builder
		expected interface{}
		getRes   func() interface{}
	}{
		{
			name:     "Builder1",
			builder:  &Builder1{},
			expected: "123",
			getRes: func() interface{} {
				return (&Builder1{}).GetResult()
			},
		},
		{
			name:     "Builder2",
			builder:  &Builder2{},
			expected: 6,
			getRes: func() interface{} {
				return (&Builder2{}).GetResult()
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			d := NewDirector(tt.builder)
			d.Construct()

			var actual interface{}
			switch b := tt.builder.(type) {
			case *Builder1:
				actual = b.GetResult()
			case *Builder2:
				actual = b.GetResult()
			default:
				t.Fatalf("unsupported builder type")
			}

			if actual != tt.expected {
				t.Fatalf("expected %v, got %v", tt.expected, actual)
			}
		})
	}
}

package test

// Cloneable 是原型对象需要实现的接口
type Cloneable interface {
	Clone() Cloneable
}

type PrototypeManager struct {
	prototypes map[string]Cloneable
}

func NewPrototypeManager() *PrototypeManager {
	return &PrototypeManager{
		prototypes: make(map[string]Cloneable),
	}
}

// Get 返回指定名称的原型克隆对象
func (p *PrototypeManager) Get(name string) Cloneable {
	proto, ok := p.prototypes[name]
	if !ok {
		return nil
	}
	return proto.Clone()
}

// Set 注册原型对象
func (p *PrototypeManager) Set(name string, prototype Cloneable) {
	p.prototypes[name] = prototype
}

package test

import "testing"

// Type1 原型类型1
type Type1 struct {
	Name string
}

func (t *Type1) Clone() Cloneable {
	tc := *t
	return &tc
}

// Type2 原型类型2
type Type2 struct {
	Name string
}

func (t *Type2) Clone() Cloneable {
	tc := *t
	return &tc
}

func setupManager() *PrototypeManager {
	manager := NewPrototypeManager()
	manager.Set("t1", &Type1{Name: "type1"})
	manager.Set("t2", &Type2{Name: "type2"})
	return manager
}

func TestPrototypeClone(t *testing.T) {
	manager := setupManager()

	tests := []struct {
		name       string
		prototype  string
		expected   string
		typeAssert string // 用于类型断言检查
	}{
		{"Type1 Clone", "t1", "type1", "Type1"},
		{"Type2 Clone", "t2", "type2", "Type2"},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			obj := manager.Get(tt.prototype)
			if obj == nil {
				t.Fatalf("Get(%s) returned nil", tt.prototype)
			}

			// 验证克隆对象不是原对象
			original := manager.prototypes[tt.prototype]
			if obj == original {
				t.Fatalf("Clone returned the same object as original")
			}

			// 类型断言并检查字段
			switch tt.typeAssert {
			case "Type1":
				casted := obj.(*Type1)
				if casted.Name != tt.expected {
					t.Fatalf("expected %s, got %s", tt.expected, casted.Name)
				}
			case "Type2":
				casted := obj.(*Type2)
				if casted.Name != tt.expected {
					t.Fatalf("expected %s, got %s", tt.expected, casted.Name)
				}
			}
		})
	}
}

package test

type API interface {
	Test() string
}

func NewAPI() API {
	return &apiImpl{
		a: NewAImpl(),
		b: NewBImpl(),
	}
}

type apiImpl struct {
	a AModule
	b BModule
}

func (api *apiImpl) Test() string {
	// 把两部分结果拼接返回
	return api.a.TestA() + api.b.TestB()
}

// --- AModule ---

type AModule interface {
	TestA() string
}

type AImpl struct{}

func NewAImpl() AModule {
	return &AImpl{}
}

func (a *AImpl) TestA() string {
	return "testA ... "
}

// --- BModule ---

type BModule interface {
	TestB() string
}

type BImpl struct{}

func NewBImpl() BModule {
	return &BImpl{}
}

func (b *BImpl) TestB() string {
	return "testB ... "
}

package test

import "testing"

func TestFacade(t *testing.T) {
	api := NewAPI()
	out := api.Test()
	expected := "testA ... testB ... "

	if out != expected {
		t.Errorf("API Test() = %q, want %q", out, expected)
	}
}

package test

type Adapter interface {
	Request() string
}

func NewAdapter(adaptee Adaptee) Adapter {
	return &adapter{
		adaptee: adaptee,
	}
}

type adapter struct {
	adaptee Adaptee
}

func (a *adapter) Request() string {
	return a.adaptee.SpecificRequest()
}

// --- Adaptee 接口与实现 ---

type Adaptee interface {
	SpecificRequest() string
}

type adaptee struct{}

func NewAdaptee() Adaptee {
	return &adaptee{}
}

func (a *adaptee) SpecificRequest() string {
	return "specific request called"
}

package test

import "testing"

func TestAdapter(t *testing.T) {
	adaptee := NewAdaptee()
	adapter := NewAdapter(adaptee)

	out := adapter.Request()
	expected := "specific request called"

	if out != expected {
		t.Errorf("Adapter Request() = %q, want %q", out, expected)
	}
}

package test

type Subject interface {
	Do() string
}

type RealSubject struct{}

func (RealSubject) Do() string {
	return "real"
}

type Proxy struct {
	real Subject
}

func NewProxy(real Subject) Subject {
	return &Proxy{real: real}
}

func (p *Proxy) Do() string {
	res := "pre:"
	res += p.real.Do()
	res += ":after"
	return res
}

package test

import "testing"

func TestProxy(t *testing.T) {
	real := &RealSubject{}
	sub := NewProxy(real)

	res := sub.Do()

	if res != "pre:real:after" {
		t.Fatalf("expect pre:real:after, got %s", res)
	}
}

package decorator

import (
	"fmt"
)

type person struct {
	Name string
}

func (p *person) show() {
	if p == nil {
		return
	}
	fmt.Println("姓名：", p.Name)
}

type AbstractPerson interface {
	show()
}

type Decorator struct {
	AbstractPerson
}

func (d *Decorator) SetDecorator(component AbstractPerson) {
	if d == nil {
		return
	}
	d.AbstractPerson = component
}

func (d *Decorator) show() {
	if d == nil {
		return
	}
	if d.AbstractPerson != nil {
		d.AbstractPerson.show()
	}
}

type TShirts struct {
	Decorator
}

func (t *TShirts) show() {
	if t == nil {
		return
	}
	t.Decorator.show()
	fmt.Println("T恤")
}

type BigTrouser struct {
	Decorator
}

func (b *BigTrouser) show() {
	if b == nil {
		return
	}
	b.Decorator.show()
	fmt.Println("大裤衩")
}

type Sneakers struct {
	Decorator
}

func (b *Sneakers) show() {
	if b == nil {
		return
	}
	b.Decorator.show()
	fmt.Println("破球鞋")
}

package decorator

import "testing"

func TestDecorator(t *testing.T) {
	p := &person{"Alice"}

	ts := new(TShirts)
	ts.SetDecorator(p)

	bt := new(BigTrouser)
	bt.SetDecorator(ts)

	sk := new(Sneakers)
	sk.SetDecorator(bt)

	// sneakers -> bigtrouser -> tshirts -> person
	sk.show()
}

func TestDecoratorChain(t *testing.T) {
	// 验证多层装饰不会 panic
	p := &person{"Bob"}
	ts := new(TShirts)
	ts.SetDecorator(p)

	bt := new(BigTrouser)
	bt.SetDecorator(ts)

	sk := new(Sneakers)
	sk.SetDecorator(bt)

	sk.show()
}

func TestDecoratorWithoutInner(t *testing.T) {
	d := new(Decorator)
	// 没有设置内部对象时，show 不应 panic
	d.show()
}

package bridge

import (
	"fmt"
)

type Phone struct {
	soft ISoftware
	name string
}

func (p *Phone) setSoft(soft ISoftware) {
	if p == nil {
		return
	}
	p.soft = soft
}

func (p *Phone) Run() {
	if p == nil {
		return
	}
	fmt.Println(p.name)
	p.soft.Run()
}

type PhoneA struct {
	Phone
}

func NewPhoneA(name string) *PhoneA {
	return &PhoneA{Phone{name: name}}
}

type PhoneB struct {
	Phone
}

func NewPhoneB(name string) *PhoneB {
	return &PhoneB{Phone{name: name}}
}

type ISoftware interface {
	Run()
}

type Software struct {
	name string
}

type SoftwareA struct {
	Software
}

func (s *Software) Run() {
	if s == nil {
		return
	}
	fmt.Println(s.name)
}

type SoftwareB struct {
	Software
}

package bridge

import "testing"

func TestBridge(t *testing.T) {
	sa := &SoftwareA{Software{"软件A"}}
	sb := &SoftwareB{Software{"软件B"}}

	pa := NewPhoneA("手机A")
	pb := NewPhoneB("手机B")

	pa.setSoft(sa)
	pb.setSoft(sb)

	// 验证手机和软件的组合可以正常执行
	pa.Run()
	pb.Run()
}

func TestBridgeSetSoft(t *testing.T) {
	pa := NewPhoneA("测试手机")
	sa := &SoftwareA{Software{"测试软件"}}
	pa.setSoft(sa)
	// 验证设置后可以运行，不会 panic
	pa.Run()
}

func TestBridgePhoneBWithSoftwareA(t *testing.T) {
	// 验证任意手机可以搭配任意软件（桥接模式的核心）
	pb := NewPhoneB("手机B")
	sa := &SoftwareA{Software{"软件A"}}
	pb.setSoft(sa)
	pb.Run()
}

package composite

import (
	“fmt”
	“strings”
)

// 公司管理接口
type Company interface {
	Name() string
	add(Company)
	remove(Company)
	display(int)
	lineOfDuty()
}

type RealCompany struct {
	name string
}

func (r *RealCompany) Name() string {
	if r == nil {
		return “”
	}
	return r.name
}

// 具体公司 -- Composite 节点，可以包含子节点
type ConcreteCompany struct {
	RealCompany
	list []Company
}

func NewConcreteCompany(name string) *ConcreteCompany {
	return &ConcreteCompany{RealCompany{name}, []Company{}}
}

func (c *ConcreteCompany) add(newc Company) {
	if c == nil {
		return
	}
	c.list = append(c.list, newc)
}

// 按名称移除（避免直接比较 interface 导致只能移除同一指针的问题）
func (c *ConcreteCompany) remove(delc Company) {
	if c == nil {
		return
	}
	for i, val := range c.list {
		if val.Name() == delc.Name() {
			c.list = append(c.list[:i], c.list[i+1:]...)
			return
		}
	}
}

func (c *ConcreteCompany) display(depth int) {
	if c == nil {
		return
	}
	fmt.Println(strings.Repeat(“-”, depth), “ “, c.name)
	for _, val := range c.list {
		val.display(depth + 2)
	}
}

func (c *ConcreteCompany) lineOfDuty() {
	if c == nil {
		return
	}
	for _, val := range c.list {
		val.lineOfDuty()
	}
}

// 人力资源部门 -- Leaf 节点
type HRDepartment struct {
	RealCompany
}

func NewHRDepartment(name string) *HRDepartment {
	return &HRDepartment{RealCompany{name}}
}

func (h *HRDepartment) add(c Company)    {}
func (h *HRDepartment) remove(c Company) {}

func (h *HRDepartment) display(depth int) {
	if h == nil {
		return
	}
	fmt.Println(strings.Repeat(“-”, depth), “ “, h.name)
}

func (h *HRDepartment) lineOfDuty() {
	if h == nil {
		return
	}
	fmt.Println(h.name, “员工招聘培训管理”)
}

// 财务部门 -- Leaf 节点
type FinanceDepartment struct {
	RealCompany
}

func NewFinanceDepartment(name string) *FinanceDepartment {
	return &FinanceDepartment{RealCompany{name}}
}

func (h *FinanceDepartment) add(c Company)    {}
func (h *FinanceDepartment) remove(c Company) {}

func (h *FinanceDepartment) display(depth int) {
	if h == nil {
		return
	}
	fmt.Println(strings.Repeat(“-”, depth), “ “, h.name)
}

func (h *FinanceDepartment) lineOfDuty() {
	if h == nil {
		return
	}
	fmt.Println(h.name, “公司财务收支管理”)
}

package composite

import (
	“strings”
	“testing”
)

func TestCompositeBuildAndDisplay(t *testing.T) {
	root := NewConcreteCompany(“北京总公司”)
	root.add(NewHRDepartment(“总公司人力资源部”))
	root.add(NewFinanceDepartment(“总公司财务部”))

	compA := NewConcreteCompany(“上海华东分公司”)
	compA.add(NewHRDepartment(“上海华东分公司人力资源部”))
	compA.add(NewFinanceDepartment(“上海华东分公司财务部”))
	root.add(compA)

	// 验证根节点有3个子节点（人力资源部、财务部、上海华东分公司）
	if len(root.list) != 3 {
		t.Errorf(“root should have 3 children, got %d”, len(root.list))
	}

	// 验证上海华东分公司有2个子节点
	if len(compA.list) != 2 {
		t.Errorf(“compA should have 2 children, got %d”, len(compA.list))
	}
}

func TestCompositeRemove(t *testing.T) {
	root := NewConcreteCompany(“总公司”)
	hr := NewHRDepartment(“人力资源部”)
	fin := NewFinanceDepartment(“财务部”)
	root.add(hr)
	root.add(fin)

	if len(root.list) != 2 {
		t.Fatalf(“expected 2 children after add, got %d”, len(root.list))
	}

	// 按名称移除（使用新创建的相同名称对象也可以移除）
	root.remove(NewHRDepartment(“人力资源部”))
	if len(root.list) != 1 {
		t.Errorf(“expected 1 child after remove, got %d”, len(root.list))
	}

	// 验证剩下的是财务部
	if root.list[0].Name() != “财务部” {
		t.Errorf(“expected remaining child to be '财务部', got %q”, root.list[0].Name())
	}
}

func TestCompositeLeafOperations(t *testing.T) {
	hr := NewHRDepartment(“HR”)
	// 叶子节点 add/remove 不应 panic
	hr.add(nil)
	hr.remove(nil)

	if hr.Name() != “HR” {
		t.Errorf(“expected name 'HR', got %q”, hr.Name())
	}
}

func TestCompositeLineOfDuty(t *testing.T) {
	// 通过名称关键词验证职责描述
	hr := NewHRDepartment(“HR”)
	fin := NewFinanceDepartment(“FIN”)

	name := hr.Name()
	if !strings.Contains(name, “HR”) {
		t.Errorf(“expected HR department, got %q”, name)
	}
	if !strings.Contains(fin.Name(), “FIN”) {
		t.Errorf(“expected FIN department, got %q”, fin.Name())
	}
}

/*
 Flyweight 享元模式：
        运用共享技术有效地支持大量细粒度的对象
 个人想法：主要思想是共享，将可以共享的部分放在对象内部，
         不可以共享的部分放在外边，享元工厂创建几个享元对象就可以了，
		这样不同的外部状态，可以针对同一个对象，给人感觉是操作多个对象，
		通过参数的形式对同一个对象的操作，像是对多个对象的操作
 日期：   20170311
*/

package test

import (
	"fmt"
)

// 享元对象接口
type IFlyweight interface {
	Operation(int) //来自外部的状态
}

// 共享对象
type ConcreteFlyweight struct {
	name string
}

func (c *ConcreteFlyweight) Operation(outState int) {
	if c == nil {
		return
	}
	fmt.Println("共享对象响应外部状态", outState)
}

// 不共享对象
type UnsharedConcreteFlyweight struct {
	name string
}

func (c *UnsharedConcreteFlyweight) Operation(outState int) {
	if c == nil {
		return
	}
	fmt.Println("不共享对象响应外部状态", outState)
}

// 享元工厂对象
type FlyweightFactory struct {
	flyweights map[string]IFlyweight
}

func (f *FlyweightFactory) Flyweight(name string) IFlyweight {
	if f == nil {
		return nil
	}
	if name == "u" {
		return &UnsharedConcreteFlyweight{"u"}
	} else if _, ok := f.flyweights[name]; !ok {
		f.flyweights[name] = &ConcreteFlyweight{name}
	}
	return f.flyweights[name]
}

func NewFlyweightFactory() *FlyweightFactory {
	ff := FlyweightFactory{make(map[string]IFlyweight)}
	ff.flyweights["a"] = &ConcreteFlyweight{"a"}
	ff.flyweights["b"] = &ConcreteFlyweight{"b"}
	return &ff
}

package test

import (
	"testing"
)

func TestFlyweight(t *testing.T) {
	ff := NewFlyweightFactory()

	fya := ff.Flyweight("a")
	fya.Operation(1)

	fyb := ff.Flyweight("b")
	fyb.Operation(2)

	fyc := ff.Flyweight("c")
	fyc.Operation(3)

	fyd := ff.Flyweight("d")
	fyd.Operation(4)

	fyu := ff.Flyweight("u")
	fyu.Operation(5)
}

package test

type Subject struct {
	observers []Observer
	context   string
}

func NewSubject() *Subject {
	return &Subject{
		observers: make([]Observer, 0),
	}
}

type Observer interface {
	Update(*Subject)
}

func (s *Subject) Attach(o Observer) {
	s.observers = append(s.observers, o)
}

func (s *Subject) notify() {
	for _, o := range s.observers {
		o.Update(s)
	}
}

func (s *Subject) UpdateContext(context string) {
	s.context = context
	s.notify()
}

func (s *Subject) Context() string {
	return s.context
}

type Reader struct {
	name     string
	received []string
}

func NewReader(name string) *Reader {
	return &Reader{
		name:     name,
		received: make([]string, 0),
	}
}

func (r *Reader) Update(s *Subject) {
	r.received = append(r.received, s.Context())
}

func (r *Reader) Received() []string {
	return r.received
}

func (r *Reader) Name() string {
	return r.name
}

package test

import "testing"

func TestObserver(t *testing.T) {
	subject := NewSubject()

	r1 := NewReader("reader1")
	r2 := NewReader("reader2")
	r3 := NewReader("reader3")

	subject.Attach(r1)
	subject.Attach(r2)
	subject.Attach(r3)

	subject.UpdateContext("observer mode")

	readers := []*Reader{r1, r2, r3}
	for _, r := range readers {
		received := r.Received()
		if len(received) != 1 {
			t.Fatalf("%s expect 1 update got %d", r.Name(), len(received))
		}
		if received[0] != "observer mode" {
			t.Fatalf("%s expect observer mode got %s", r.Name(), received[0])
		}
	}
}

package interpreter

import "strconv"

// Node 抽象表达式接口
type Node interface {
	Interpret() int
}

// NumNode 终结符表达式 — 数字
type NumNode struct {
	num int
}

func NewNumNode(s string) *NumNode {
	n, _ := strconv.Atoi(s)
	return &NumNode{num: n}
}

func (n *NumNode) Interpret() int {
	return n.num
}

// AddNode 非终结符表达式 — 加法
type AddNode struct {
	left, right Node
}

func NewAddNode(left, right Node) *AddNode {
	return &AddNode{left: left, right: right}
}

func (n *AddNode) Interpret() int {
	return n.left.Interpret() + n.right.Interpret()
}

// SubNode 非终结符表达式 — 减法
type SubNode struct {
	left, right Node
}

func NewSubNode(left, right Node) *SubNode {
	return &SubNode{left: left, right: right}
}

func (n *SubNode) Interpret() int {
	return n.left.Interpret() - n.right.Interpret()
}

// Parser 简单的解析器：将 "1+2-3" 格式的表达式解析为 AST
func Parser(input string) Node {
	tokens := tokenize(input)
	if len(tokens) == 0 {
		return &NumNode{0}
	}

	var root Node = NewNumNode(tokens[0])
	for i := 1; i < len(tokens); i += 2 {
		op := tokens[i]
		right := NewNumNode(tokens[i+1])
		switch op {
		case "+":
			root = NewAddNode(root, right)
		case "-":
			root = NewSubNode(root, right)
		}
	}
	return root
}

func tokenize(input string) []string {
	var tokens []string
	var buf []byte
	for i := 0; i < len(input); i++ {
		c := input[i]
		if c == '+' || c == '-' {
			if len(buf) > 0 {
				tokens = append(tokens, string(buf))
				buf = buf[:0]
			}
			tokens = append(tokens, string(c))
		} else {
			buf = append(buf, c)
		}
	}
	if len(buf) > 0 {
		tokens = append(tokens, string(buf))
	}
	return tokens
}

package interpreter

import "testing"

func TestInterpreter(t *testing.T) {
	tests := []struct {
		input    string
		expected int
	}{
		{"1+2", 3},
		{"1+2+3", 6},
		{"10-3", 7},
		{"10-3-2", 5},
		{"1+2-3", 0},
		{"5-3+2", 4},
		{"0", 0},
		{"100", 100},
	}

	for _, tt := range tests {
		t.Run(tt.input, func(t *testing.T) {
			node := Parser(tt.input)
			result := node.Interpret()
			if result != tt.expected {
				t.Errorf("Parser(%q).Interpret() = %d, want %d", tt.input, result, tt.expected)
			}
		})
	}
}

package template_method

import (
	"fmt"
)

type getfood interface {
	first()
	second()
	third()
}

type template struct {
	g getfood
}

func (b *template) getsomefood() {
	if b == nil {
		return
	}
	b.g.first()
	b.g.second()
	b.g.third()
}

type bingA struct {
	template
}

func NewBingA() *bingA {
	b := bingA{}
	return &b
}

func (b *bingA) first() {
	if b == nil {
		return
	}
	fmt.Println("打开冰箱")
}

func (b *bingA) second() {
	if b == nil {
		return
	}
	fmt.Println("拿出东西")
}

func (b *bingA) third() {
	if b == nil {
		return
	}
	fmt.Println("关闭冰箱")
}

type Guo struct {
	template
}

func NewGuo() *Guo {
	b := Guo{}
	return &b
}

func (b *Guo) first() {
	if b == nil {
		return
	}
	fmt.Println("打开锅")
}

func (b *Guo) second() {
	if b == nil {
		return
	}
	fmt.Println("拿出东西锅")
}

func (b *Guo) third() {
	if b == nil {
		return
	}
	fmt.Println("关闭锅")
}

package template_method

import "testing"

func TestTemplate(t *testing.T) {
	b := NewBingA()
	b.g = b
	b.getsomefood()

	g := NewGuo()
	g.g = g
	g.getsomefood()
}

func TestTemplateBingA(t *testing.T) {
	b := NewBingA()
	b.g = b
	// 验证模板方法不会 panic
	b.getsomefood()
}

func TestTemplateGuo(t *testing.T) {
	g := NewGuo()
	g.g = g
	// 验证模板方法不会 panic
	g.getsomefood()
}

/*
 Chain Of Responsibility 职责链模式：
        使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。
        将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止

 个人想法：MFC的消息队列机制
*/
package test

import (
	"fmt"
)

const (
	constHandler = iota
	constHandlerA
	constHandlerB
)

// 处理请求接口
type IHandler interface {
	SetSuccessor(IHandler)
	HandleRequest(int) int
}

// 实现处理请求的接口的基本结构体类型
type Handler struct {
	successor IHandler // 继承者
}

func (h *Handler) SetSuccessor(i IHandler) {
	if h == nil {
		return
	}
	h.successor = i
}

// 具体处理结构体，这里简单处理int类型的请求，判断是否在[1-10]之间，是：处理，否：交给successor处理
type ConcreteHandlerA struct {
	Handler
}

func (c *ConcreteHandlerA) HandleRequest(req int) int {
	if c == nil {
		return constHandler
	}
	if req > 0 && req < 11 {
		fmt.Println("ConcreteHandlerA可以处理这个请求")
		return constHandlerA
	} else if c.successor != nil {
		return c.successor.HandleRequest(req)
	}
	return constHandler
}

func NewConcreteHandlerA() *ConcreteHandlerA {
	return &ConcreteHandlerA{}
}

// 具体处理结构体，这里简单处理int类型的请求，判断是否在[11-20]之间，是：处理，否：交给successor处理
type ConcreteHandlerB struct {
	Handler
}

func (c *ConcreteHandlerB) HandleRequest(req int) int {
	if c == nil {
		return constHandler
	}
	if req > 10 && req < 21 {
		fmt.Println("ConcreteHandlerB可以处理这个请求")
		return constHandlerB
	} else if c.successor != nil {
		return c.successor.HandleRequest(req)
	}
	return constHandler
}

func NewConcreteHandlerB() *ConcreteHandlerB {
	return &ConcreteHandlerB{}
}

package test

import (
	"testing"
)

func TestChainOfResponsibility(t *testing.T) {
	ca := NewConcreteHandlerA()
	cb := NewConcreteHandlerB()
	ca.SetSuccessor(cb)

	var req = [][]int{{1, constHandlerA}, {4, constHandlerA}, {11, constHandlerB}, {0, constHandler}}
	for _, val := range req {
		if val[1] != ca.HandleRequest(val[0]) {
			t.Error("错误")
		}
	}
}

package state

import (
	"fmt"
)

// Work 工作类 -- Context
type Work struct {
	hour  int
	state State
}

func (w *Work) Hour() int {
	if w == nil {
		return -1
	}
	return w.hour
}

func (w *Work) State() State {
	if w == nil {
		return nil
	}
	return w.state
}

func (w *Work) SetHour(h int) {
	if w == nil {
		return
	}
	w.hour = h
}

func (w *Work) SetState(s State) {
	if w == nil {
		return
	}
	w.state = s
}

func (w *Work) writeProgram() {
	if w == nil {
		return
	}
	w.state.writeProgram(w)
}

func NewWork() *Work {
	state := new(morningState)
	return &Work{state: state}
}

type State interface {
	writeProgram(w *Work)
}

// morningState 上午时分状态
type morningState struct{}

func (m *morningState) writeProgram(w *Work) {
	if w.Hour() < 12 {
		fmt.Println("现在是上午时分", w.Hour())
	} else {
		w.SetState(new(NoonState))
		w.writeProgram()
	}
}

// NoonState 中午时分状态
type NoonState struct{}

func (m *NoonState) writeProgram(w *Work) {
	if w.Hour() < 13 {
		fmt.Println("现在是中午时分", w.Hour())
	} else {
		w.SetState(new(AfternoonState))
		w.writeProgram()
	}
}

// AfternoonState 下午时分状态
type AfternoonState struct{}

func (m *AfternoonState) writeProgram(w *Work) {
	if w.Hour() < 17 {
		fmt.Println("现在是下午时分", w.Hour())
	} else {
		w.SetState(new(EveningState))
		w.writeProgram()
	}
}

// EveningState 晚上时分状态
type EveningState struct{}

func (m *EveningState) writeProgram(w *Work) {
	if w.Hour() < 21 {
		fmt.Println("现在是晚上时分", w.Hour())
	} else {
		fmt.Println("现在开始睡觉", w.Hour())
	}
}

package state

import (
	"testing"
)

func TestStateMorning(t *testing.T) {
	w := NewWork()
	w.SetHour(9)
	// 9点应该是上午状态
	if w.State() == nil {
		t.Fatal("state should not be nil")
	}
	w.writeProgram()
}

func TestStateTransition(t *testing.T) {
	tests := []struct {
		name string
		hour int
	}{
		{"morning", 9},
		{"noon", 12},
		{"afternoon", 14},
		{"evening", 18},
		{"sleep", 21},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			w := NewWork()
			w.SetHour(tt.hour)
			w.writeProgram()
		})
	}
}

func TestStateHourGetter(t *testing.T) {
	w := NewWork()
	w.SetHour(15)
	if w.Hour() != 15 {
		t.Errorf("expected hour 15, got %d", w.Hour())
	}
}

func TestNewWork(t *testing.T) {
	w := NewWork()
	if w == nil {
		t.Fatal("NewWork() returned nil")
	}
	if w.State() == nil {
		t.Error("initial state should not be nil")
	}
}