package neo

Import Path
	github.com/gotd/neo (on go.dev)

Dependency Relation
	imports 7 packages, and imported by one package

Involved Source Files

	    moment.go
	  d neo.go
		Package neo implements side effects simulation for testing.

	    net.go
	    ticker.go
	    time.go
	    timer.go
Package-Level Type Names (total 13, in which 7 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type NAT (struct)
		NAT implements facility for Network Address Translation simulation.
		
		Basic example:
			[ A ] <-----> [ NAT1 ] <-----> [ NAT2 ] <-----> [ B ]
		     IPa              IPa'     IPb'             IPb
		
			1) A sends packet P with dst = IPb'
		 2) NAT1 receives packet P and changes it's src to IPa',
		  sending it to NAT2 from IPa'.
		 3) NAT2 receives packet P from IPa' to IPb', does a lookup to
		  NAT translation table and finds association IPb' <-> IPb.
		  Then it sends packet P to B.
		 4) B receives packet P from NAT2, observing that it has src = IPa'.
		
		 Now B can repeat steps 1-4 and send packet back.
		
		 IPa  = 10.5.0.1:30000
		 IPa' = 83.30.100.1:23100
		 IPb' = 91.10.100.1:13000
		 IPb  = 10.1.0.1:20000

	 type Net (struct)
		Net is virtual "net" package, implements mesh of peers.

		Fields (only one, which is unexported)
			/* one unexported ... *//* one unexported: */
			peers map[string]*PacketConn
		Methods (total 2, both are exported)
			(*Net) ListenPacket(network, address string) (net.PacketConn, error)
				ListenPacket announces on the local network address.

			(*Net) ResolveUDPAddr(network, address string) (*net.UDPAddr, error)
				ResolveUDPAddr returns an address of UDP end point.


	 type NetAddr (struct)

		Fields (total 2, both are exported)
			Address string
			Net string
		Methods (total 2, both are exported)
			( NetAddr) Network() string
			( NetAddr) String() string
		Implements (at least 4, in which 2 are exported)
			 NetAddr : fmt.Stringer
			 NetAddr : net.Addr
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			 NetAddr : context.stringer
			 NetAddr : runtime.stringer

	 type PacketConn (struct)
		PacketConn simulates mesh peer of Net.

		Fields (total 9, none are exported)
			/* 9 unexporteds ... *//* 9 unexporteds: */
			addr net.Addr
			closed bool
			closedMux sync.Mutex
			deadline notifier
			mux sync.Mutex
			net *Net
			packets chan packet
			readDeadline notifier
			writeDeadline notifier
		Methods (total 8, in which 7 are exported)
			(*PacketConn) Close() error
				Close closes the connection.

			(*PacketConn) LocalAddr() net.Addr
			(*PacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error)
				ReadFrom reads a packet from the connection,
				copying the payload into p.

			(*PacketConn) SetDeadline(t time.Time) error
			(*PacketConn) SetReadDeadline(t time.Time) error
			(*PacketConn) SetWriteDeadline(t time.Time) error
			(*PacketConn) WriteTo(p []byte, a net.Addr) (n int, err error)
				WriteTo writes a packet with payload p to addr.

			/* one unexported ... *//* one unexported: */
			(*PacketConn) ok() bool
		Implements (at least 2, both are exported)
			*PacketConn : io.Closer
			*PacketConn : net.PacketConn

	 type Ticker (interface)
		Ticker abstracts a channel that delivers ``ticks'' of a clock at intervals.

		Methods (total 3, all are exported)
			( Ticker) C() <-chan time.Time
			( Ticker) Reset(d time.Duration)
			( Ticker) Stop()
		Implemented By (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*ticker
			 github.com/gotd/td/clock.systemTicker
		As Outputs Of (at least 2, both are exported)
			func (*Time).Ticker(d time.Duration) Ticker
			func github.com/gotd/td/clock.Clock.Ticker(d time.Duration) clock.Ticker

	 type Time (struct)
		Time simulates temporal interactions.
		
		All methods are goroutine-safe.

		Fields (total 5, none are exported)
			/* 5 unexporteds ... *//* 5 unexporteds: */
			momentID int
			moments map[int]moment
			mux sync.Mutex
				mux guards internal state. Note that all methods without Unlocked
				suffix acquire mux.

			now time.Time
			observers []chan struct{}
		Methods (total 18, in which 10 are exported)
			(*Time) After(d time.Duration) <-chan time.Time
				After returns new channel that will receive time.Time value with current tme after
				specified duration.

			(*Time) Now() time.Time
				Now returns the current time.

			(*Time) Observe() <-chan struct{}
				Observe return channel that closes on clock calls. The current implementation
				also closes the channel on Ticker’s ticks.

			(*Time) Set(now time.Time)
				Set travels to specified time.
				
				Also triggers temporal effects.

			(*Time) Sleep(d time.Duration)
				Sleep blocks until duration is elapsed.

			(*Time) Ticker(d time.Duration) Ticker
			(*Time) Timer(d time.Duration) Timer
			(*Time) Travel(d time.Duration) time.Time
				Travel adds duration to current time and returns result.
				
				Also triggers temporal effects.

			(*Time) TravelDate(years, months, days int) time.Time
				TravelDate applies AddDate to current time and returns result.
				
				Also triggers temporal effects.

			(*Time) When(d time.Duration) time.Time
				When returns relative time point.

			/* 8 unexporteds ... *//* 8 unexporteds: */
			(*Time) observeUnlocked()
			(*Time) plan(when time.Time, do func(now time.Time)) int
			(*Time) planUnlocked(when time.Time, do func(now time.Time)) int
			(*Time) reset(d time.Duration, id int, do func(now time.Time), durp *time.Duration)
				reset adjusts the moment with the given ID to run after the d duration. It
				creates a new moment if the moment does not already exist. If durp pointer
				is not nil, it is updated with d value while reset is holding Time’s lock.

			(*Time) resetUnlocked(d time.Duration, id int, do func(now time.Time), durp *time.Duration)
				resetUnlocked is like reset but does not acquire the Time’s lock.

			(*Time) setUnlocked(now time.Time)
				setUnlocked sets the current time to the given now time and triggers temporal
				effects.

			(*Time) stop(id int) bool
				stop removes the moment with the given ID from the list of scheduled moments.
				It returns true if a moment existed for the given ID, otherwise it is no-op.

			(*Time) tickUnlocked() moments
				tickUnlocked applies all scheduled temporal effects.

		Implements (at least 2, both are exported)
			*Time : github.com/gotd/td/clock.Clock
			*Time : github.com/cenkalti/backoff/v4.Clock
		As Outputs Of (at least one exported)
			func NewTime(now time.Time) *Time

	 type Timer (interface)
		Timer abstracts a single event.

		Methods (total 3, all are exported)
			( Timer) C() <-chan time.Time
			( Timer) Reset(d time.Duration)
			( Timer) Stop() bool
		Implemented By (at least 2, neither is exported)
			/* 2+ unexporteds ... *//* 2+ unexporteds: */
			*timer
			 github.com/gotd/td/clock.systemTimer
		As Outputs Of (at least 2, both are exported)
			func (*Time).Timer(d time.Duration) Timer
			func github.com/gotd/td/clock.Clock.Timer(d time.Duration) clock.Timer
		As Inputs Of (at least one exported)
			func github.com/gotd/td/clock.StopTimer(t clock.Timer)

	/* 6 unexporteds ... *//* 6 unexporteds: */
	 type moment (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			do func(time time.Time)
			when time.Time

	 type moments ([])

		Methods (total 4, in which 3 are exported)
			( moments) Len() int
			( moments) Less(i, j int) bool
			( moments) Swap(i, j int)
			/* one unexported ... *//* one unexported: */
			( moments) do(t time.Time)
		Implements (at least one exported)
			 moments : sort.Interface
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func (*Time).tickUnlocked() moments

	 type notifier (chan)

		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func simpleDeadline(t time.Time) notifier

	 type packet (struct)

		Fields (total 2, neither is exported)
			/* 2 unexporteds ... *//* 2 unexporteds: */
			addr net.Addr
			buf []byte

	 type ticker (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			ch chan time.Time
			dur time.Duration
			id int
			time *Time
		Methods (total 4, in which 3 are exported)
			(*ticker) C() <-chan time.Time
			(*ticker) Reset(d time.Duration)
			(*ticker) Stop()
			/* one unexported ... *//* one unexported: */
			(*ticker) do(now time.Time)
				do is the ticker’s moment callback. It sends the now time to the underlying
				channel and plans a new moment for the next tick. Note that do runs under
				Time’s lock.

		Implements (at least one exported)
			*ticker : Ticker

	 type timer (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			ch chan time.Time
			id int
			time *Time
		Methods (total 4, in which 3 are exported)
			(*timer) C() <-chan time.Time
			(*timer) Reset(d time.Duration)
			(*timer) Stop() bool
			/* one unexported ... *//* one unexported: */
			(*timer) do(now time.Time)
				do is the timer’s moment callback. It sends the now time to the underlying
				channel. Note that do runs under Time’s lock.

		Implements (at least one exported)
			*timer : Timer


Package-Level Functions (total 3, in which 1 is exported)

	 func NewTime(now time.Time) *Time
		NewTime returns new temporal simulator.

	/* 2 unexporteds ... *//* 2 unexporteds: */
	 func addrKey(a net.Addr) string
	 func simpleDeadline(t time.Time) notifier
Package-Level Variables (only one, which is exported)

	  var ErrDeadline error

The pages are generated with Golds v0.6.7. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.