func TestParseInfo(t *testing.T) {
expectations := map[string]*TVNameParseResult{
"Sleepy.Hollow.S03E01.720p.HDTV.x264-AVS": {
Name: "Sleepy Hollow",
CleanedName: "Sleepy Hollow S03E01 720p HDTV x264-AVS",
Country: "",
Episode: "1",
Season: "3",
Airdate: "",
},
"NBC.Nightly.News.2016.02.17.WEB-DL.x264-2Maverick": {
Name: "NBC Nightly News",
CleanedName: "NBC Nightly News 2016 02 17 WEB-DL x264-2Maverick",
Country: "",
Episode: "02/17",
Season: "2016",
Airdate: "2016.02.17",
},
}
for name, v := range expectations {
res, err := ParseInfo(name)
if err != nil {
t.Fatalf("Error %v", err)
}
if !reflect.DeepEqual(v, res) {
t.Errorf("Diff in Parse output for %s", name)
fmt.Println("Expected:")
spew.Dump(v)
fmt.Println("Got:")
spew.Dump(res)
}
}
}
func main() {
fileSet := token.NewFileSet()
astFile, err := parser.ParseFile(fileSet, "minimal.go", nil, parser.ParseComments)
if err != nil {
panic(err)
}
ast.Print(fileSet, astFile)
return
astFile.Decls = append(astFile.Decls[:0], append([]ast.Decl{&ast.FuncDecl{
Name: ast.NewIdent("MyNewFunc"),
Type: &ast.FuncType{
Func: 15,
Params: &ast.FieldList{
Opening: 29,
Closing: 30,
},
},
}}, astFile.Decls[0:]...)...)
offset := astFile.Decls[0].End() - astFile.Decls[0].Pos()
intoffset := int(offset)
fmt.Println("offset", offset)
astFile.Comments[0].List[0].Slash += offset
// astFile.Comments[0].List[0].Slash = 18
astFile.Decls[1].(*ast.GenDecl).TokPos += offset
astFile.Decls[1].(*ast.GenDecl).Lparen += offset
astFile.Decls[1].(*ast.GenDecl).Rparen += offset
fileSetFile := fileSet.File(1)
newFileSet := token.NewFileSet()
newFileSetFile := newFileSet.AddFile("whatever", 1, fileSetFile.Size()+int(offset))
newFileSetFile.SetLines([]int{
0,
13,
14,
15,
15 + intoffset,
20 + intoffset,
21 + intoffset,
32 + intoffset,
33 + intoffset,
}) // hardcoded for now
fmt.Println("astFile:")
spew.Dump(astFile)
fmt.Println()
fmt.Println()
fmt.Println("fileSet:")
spew.Dump(fileSet)
buf := new(bytes.Buffer)
err = printer.Fprint(buf, newFileSet, astFile)
if err != nil {
panic(err)
}
fmt.Println(buf)
}
func (c *ColorChannel) SetColor(state *channels.ColorState) error {
if state.Mode != "hue" {
return fmt.Errorf("TODO: Only color mode 'hue' is supported atm.")
}
spew.Dump("setting color", state)
hue := uint32(*state.Hue * float64(math.MaxUint8-1))
saturation := uint32(*state.Saturation * float64(math.MaxUint8-1))
request := &gateway.DevSetColorReq{
DstAddress: &gateway.GwAddressStructT{
AddressType: gateway.GwAddressTypeT_UNICAST.Enum(),
IeeeAddr: c.device.deviceInfo.IeeeAddress,
},
HueValue: &hue,
SaturationValue: &saturation,
}
spew.Dump(request)
response := &gateway.GwZigbeeGenericRspInd{}
err := c.device.driver.gatewayConn.SendAsyncCommand(request, response, 2*time.Second)
if err != nil {
return fmt.Errorf("Error setting color state : %s", err)
}
if response.Status.String() != "STATUS_SUCCESS" {
return fmt.Errorf("Failed to set color state. status: %s", response.Status.String())
}
return c.fetchState()
}
func ReadBinlog(reader io.Reader) (err error) {
c := &proto.BufReader{Reader: bufio.NewReader(reader)}
buf := &bytes.Buffer{}
r := &proto.BufReader{Reader: bufio.NewReader(buf)}
tmp := make([]byte, 4)
_, err = c.Read(tmp)
if err != nil {
return
}
// http://dev.mysql.com/doc/internals/en/binlog-file-header.html
if bytes.Compare(tmp, []byte{0xfe, 0x62, 0x69, 0x6e}) != 0 {
err = ErrFileHeader
return
}
h := &EventHeader{}
h.Read(c)
spew.Dump(h)
_, err = io.CopyN(buf, c, int64(h.EventSize))
if err != nil {
panic(err)
}
f := &FormatDescriptionEvent{}
f.Read(r)
spew.Dump(f)
return
}
func main() {
parser := yasha.ParserFromFile("/home/manveru/Dropbox/Public/d2rp_test_replays/813230338.dem")
parser.OnFileInfo = func(fileinfo *dota.CDemoFileInfo) { spew.Dump(fileinfo) }
parser.OnSayText2 = func(tick int, obj *dota.CUserMsg_SayText2) { spew.Dump(tick, obj) }
parser.OnChatEvent = func(tick int, obj *dota.CDOTAUserMsg_ChatEvent) { spew.Dump(tick, obj) }
parser.Parse()
}
func TestPubKeys(t *testing.T) {
for _, test := range pubKeyTests {
pk, err := btcec.ParsePubKey(test.key, btcec.S256())
if err != nil {
if test.isValid {
t.Errorf("%s pubkey failed when shouldn't %v",
test.name, err)
}
continue
}
if !test.isValid {
t.Errorf("%s counted as valid when it should fail",
test.name)
continue
}
var pkStr []byte
switch test.format {
case btcec.TstPubkeyUncompressed:
pkStr = (*btcec.PublicKey)(pk).SerializeUncompressed()
case btcec.TstPubkeyCompressed:
pkStr = (*btcec.PublicKey)(pk).SerializeCompressed()
case btcec.TstPubkeyHybrid:
pkStr = (*btcec.PublicKey)(pk).SerializeHybrid()
}
if !bytes.Equal(test.key, pkStr) {
t.Errorf("%s pubkey: serialized keys do not match.",
test.name)
spew.Dump(test.key)
spew.Dump(pkStr)
}
}
}
func main() {
a := []interface{}{1, 1.1, "abc", 2, 2.2, "def", 3, 3.3}
fmt.Println(sumOfArray(a))
fmt.Println(sumOfFloat(a))
fmt.Printf("\n--- omake ---\n\n")
masano := newHuman("masano")
dog := newAnimal("pochi")
monster := newMonster("godzilla")
var g greeter
g = masano
ret1, ok1 := g.(greeter) // greeter を実装しているかチェック。
spew.Dump(ret1, ok1)
g.greet()
fmt.Println()
g = dog
ret2, ok2 := g.(*animal) // animal 構造体かどうかチェック。メソッドレシーバが *animal なのでここは *animal になるっぽい。よくわからんが。
spew.Dump(ret2, ok2)
g.greet()
fmt.Println()
// インターフェースじゃなかったらキャストすればよい。
ret3, ok3 := interface{}(monster).(greeter) // greeter を実装しているかチェック。
ret4, ok4 := interface{}(monster.name).(string) // monster.name は string かチェック。
spew.Dump(ret3, ok3, ret4, ok4)
}
func main() {
var a Figure = newTriangle(10, 10) // Triangle 構造体はインタフェース Figure を実装しているので、Figure 型になれる。
fmt.Println(a.kindOf())
fmt.Println(a.area())
a.print()
// 以下の図形も同様。
var b Figure = newRectangle(10, 10)
fmt.Println(b.kindOf())
fmt.Println(b.area())
b.print()
c := newCircle(100) // この場合は何型なんだ？
fmt.Println(c.kindOf())
fmt.Println(c.area())
c.print()
fmt.Println()
spew.Dump(a, b, c) // 別に Figure 型になる、というわけではないのか。
fmt.Println()
var interfaced Figure
interfaced = newTriangle(1, 1)
spew.Dump(interfaced) // 明示的にインターフェース型の変数を用意してそれに代入しても、Triangle 型は Triangle 型のようだ。
fmt.Println()
// 各図形は Figure インターフェースを実装した Figure 型だぜ。
// これで sumOfArea() が使えるぜ。
var figures []Figure = []Figure{a, b, c}
// やったぜ。
fmt.Println(sumOfArea(figures))
}
func (c *Client) SetTags(uid string, fields map[string]interface{}) error {
session := c.MgoSession.New()
defer session.Close()
store := session.DB(c.Cfg.Mongo.Db).C("Storage")
fields["version"] = 0
timestamp := int64(time.Now().Unix() / 1000)
change := mgo.Change{
Update: bson.M{
"$set": bson.M{"last_visit": timestamp},
"$inc": bson.M(fields),
},
ReturnNew: true,
Upsert: true,
}
resultUps := Storage{}
info, err := store.Find(bson.M{"uid": uid}).Apply(change, &resultUps)
if c.Debug {
fmt.Print("set tags info: ")
spew.Dump(info)
fmt.Print("resultUps: ")
spew.Dump(resultUps)
}
if err != nil {
panic(err)
}
return nil
}
func TestWidth(t *testing.T) {
s0 := "つのだ☆HIRO"
s1 := "11111111111"
spew.Dump(s0)
spew.Dump(s1)
// above not align for setting East Asian Ambiguous to wide!!
if strWidth(s0) != strWidth(s1) {
t.Error("str len failed")
}
len1 := []rune{'a', '2', '&', '｢', 'ｵ', '｡'} //will false: 'ᆵ', 'ᄚ', 'ᄒ'
for _, v := range len1 {
if charWidth(v) != 1 {
t.Error("len1 failed")
}
}
len2 := []rune{'漢', '字', '한', '자', '你', '好', 'だ', '。', '％', 'ｓ', 'Ｅ', 'ョ', '、', 'ヲ'}
for _, v := range len2 {
if charWidth(v) != 2 {
t.Error("len2 failed")
}
}
}
func TestReplSetGetStatusResponseRewriterSuccess(t *testing.T) {
proxyMapper := fakeProxyMapper{
m: map[string]string{
"a": "1",
"b": "2",
"c": "3",
},
}
in := bson.M{
"members": []interface{}{
bson.M{
"name": "a",
"stateStr": "PRIMARY",
},
bson.M{
"name": "b",
},
bson.M{
"name": "c",
"stateStr": "ARBITER",
},
},
}
out := bson.M{
"members": []interface{}{
bson.M{
"name": "1",
"stateStr": "PRIMARY",
},
bson.M{
"name": "2",
},
bson.M{
"name": "3",
"stateStr": "ARBITER",
},
},
}
r := &ReplSetGetStatusResponseRewriter{
ProxyMapper: proxyMapper,
ReplyRW: &ReplyRW{},
}
var client bytes.Buffer
if err := r.Rewrite(&client, fakeSingleDocReply(in)); err != nil {
t.Fatal(err)
}
actualOut := bson.M{}
doc := client.Bytes()[headerLen+len(emptyPrefix):]
if err := bson.Unmarshal(doc, &actualOut); err != nil {
t.Fatal(err)
}
if !reflect.DeepEqual(out, actualOut) {
spew.Dump(out)
spew.Dump(actualOut)
t.Fatal("did not get expected output")
}
}
func main() {
a := "hello, world"
b := []byte{'h', 'y'}
// byte スライスは ASCII 文字しかダメってこと？
// でも file.go はちゃんとできてるぞ？
// c := []byte{'你', '你'}
// あー違う、文字列を []byte にするんだから、こうだ。
c := []byte("你好")
fmt.Printf("[%s]\n", a)
fmt.Printf("[%20s]\n", a)
fmt.Printf("[%-20s]\n", a)
fmt.Printf("[%q]\n", a)
fmt.Printf("[%20q]\n", a)
fmt.Printf("[%-20q]\n", a)
fmt.Printf("[%s]\n", b)
fmt.Printf("[%20s]\n", b)
fmt.Printf("[%-20s]\n", b)
fmt.Printf("[%q]\n", b)
fmt.Printf("[%20q]\n", b)
fmt.Printf("[%-20q]\n", b)
fmt.Printf("[%s]\n", c)
fmt.Printf("[%20s]\n", c)
fmt.Printf("[%-20s]\n", c)
fmt.Printf("[%q]\n", c)
fmt.Printf("[%20q]\n", c)
fmt.Printf("[%-20q]\n", c)
// "你好" はたぶん 1 文字 3 byte なんですかね。
fmt.Println()
fmt.Println("你好 な []byte をループで回す")
for _, v := range c {
spew.Dump(v)
}
// ふむふむ！
// 文字（列）は []byte (uint8: 0 - 255) である。
// 16 進数表記に直したらご覧の通りです！
fmt.Println()
fmt.Println("你を 16 進数で")
fmt.Printf("%x\n", "你")
fmt.Println("你の []byte を 16 進数で")
fmt.Printf("%x %x %x\n", c[0], c[1], c[2])
// で、rune ってのはコードポイント（Unicode 規格における、その文字の ID みたいなもん）を int32 な値で示している。
// コードポイントの文脈では、16 進数な rune 値がコードポイントになる。
// たとえば '你' は int32: 20320 で 16 進数だと 4f60 である。
// コードポイントはつまり、U+4f60 となる。
fmt.Println()
fmt.Println("你 の rune")
spew.Dump('你')
fmt.Println("你 の rune を 16 進数で")
fmt.Printf("%x\n", '你')
fmt.Println("你 の rune をコードポイントで")
fmt.Printf("%U\n", '你')
}
// Test groups creation
func testScaled(t *testing.T) {
//Init
RemoveAllGroups()
RemoveAllPriceRules()
groupID := "ProductsToScale"
//createGroup
group := new(Group)
group.Type = ProductGroup
group.ID = groupID
group.Name = groupID
//create pricerule
priceRule := NewPriceRule(PriceRuleIDSale)
priceRule.Name = map[string]string{
"de": PriceRuleIDSale,
"fr": PriceRuleIDSale,
"it": PriceRuleIDSale,
}
priceRule.Type = TypePromotionOrder
priceRule.Description = priceRule.Name
priceRule.Action = ActionScaled
priceRule.ScaledAmounts = append(priceRule.ScaledAmounts, ScaledAmountLevel{FromValue: 100.0, ToValue: 150.0, Amount: 10, IsScaledAmountPercentage: true})
priceRule.ScaledAmounts = append(priceRule.ScaledAmounts, ScaledAmountLevel{FromValue: 150.01, ToValue: 100000.0, Amount: 50, IsScaledAmountPercentage: true})
priceRule.MaxUses = 10
priceRule.MaxUsesPerCustomer = 10
priceRule.WhichXYFree = XYCheapestFree
priceRule.IncludedProductGroupIDS = []string{groupID}
priceRule.IncludedCustomerGroupIDS = []string{}
//insert as well
group.AddGroupItemIDs([]string{ProductID1SKU1})
err := group.Upsert()
if err != nil {
log.Println(err)
}
//create order
orderVo, err := createMockOrderScaled(t)
if err != nil {
panic(err)
}
now := time.Now()
discountsVo, summary, err := ApplyDiscounts(orderVo, []string{""}, "", 0.05)
timeTrack(now, "Apply scaled voucher")
defer removeOrder(orderVo)
if err != nil {
panic(err)
}
fmt.Println("discounts for scaled percentage")
spew.Dump(discountsVo)
spew.Dump(*summary)
}
func TestCanvasUnset(t *testing.T) {
c := NewCanvas()
c.Set(0, 0)
c.Set(0, 1)
c.Set(0, 2)
c.Unset(0, 2)
spew.Dump(c)
c.Unset(0, 3)
spew.Dump(c)
}
func main() {
fmt.Println("Welcome to huexample")
brokerDetailsSlice, err := hue.DiscoverBridges()
if err != nil {
fmt.Println("Error while discovering bridges:", err)
return
}
if len(brokerDetailsSlice) == 0 {
fmt.Println("No bridge details found. Stopping.")
return
}
fmt.Printf("Found %d bridges:\n", len(brokerDetailsSlice))
spew.Dump(brokerDetailsSlice)
fmt.Printf("Continueing with first bridge found, id: %s\n", brokerDetailsSlice[0].ID)
fmt.Println("Going to create user with empty username, bridge will generate a username.")
bridge := hue.NewBridge(brokerDetailsSlice[0].InternalIPAddress)
newUsername, err := bridge.CreateNewUser("huexample", "")
if err != nil {
fmt.Printf("have error: %s\n", err)
return
}
fmt.Printf("Successfully created new user. Got username: %s\n", newUsername)
// update the Username field on Bridge instance with the user we just created
bridge.Username = newUsername
bridgeConfiguration, err := bridge.FetchConfiguration()
if err != nil {
fmt.Printf("have error: %s\n", err)
return
}
fmt.Printf("Bridge name is '%s'.\n", bridgeConfiguration.Name)
fmt.Printf("Bridge has %d users.\n", len(bridgeConfiguration.Whitelist))
lights, err := bridge.Lights()
if err != nil {
fmt.Printf("have error: %s\n", err)
return
}
fmt.Printf("Have %d lights.\n", len(lights))
spew.Dump(lights[0].Attributes())
// err = lights[0].SetName("Lange lamp")
// if err != nil {
// fmt.Printf("Have error: %s\n", err)
// }
}
func checkBlock(client *btcrpcclient.Client, blockNum int64) {
blockHash, err := client.GetBlockHash(653895)
if err != nil {
logger.Crit(err.Error())
return
}
block, err := client.GetBlock(blockHash)
if err != nil {
logger.Crit(err.Error())
return
}
txs := block.Transactions()
var processedBlock = &message.ProcessedBlock{make([]*message.ProcessedTx, len(txs))}
logger.Info("Processing txs...")
for txIndex, tx := range txs {
vouts := tx.MsgTx().TxOut
result := make([]*message.TxResult, len(vouts))
for i, vout := range vouts {
addr := NewAddrFromPkScript(vout.PkScript, true)
if addr != nil {
result[i] = &message.TxResult{
&message.TxResult_Transfer{
&message.ValueTransfer{
addr.String(),
int32(vout.Value),
},
},
}
} else {
result[i] = &message.TxResult{
&message.TxResult_Msg{
&message.OpReturnMsg{string(decodePkScript(vout.PkScript))},
},
}
}
}
processedBlock.Txs[txIndex] = &message.ProcessedTx{
tx.Sha().String(),
result,
}
}
spew.Dump(processedBlock)
data, err := proto.Marshal(processedBlock)
if err != nil {
logger.Crit(err.Error())
} else {
logger.Info("Publish to ZMQ...")
spew.Dump(sender)
sender.SendBytes(data, 0)
}
logger.Info("Process done.")
}
func TestFileCreate(t *testing.T) {
client := cuckoo.NewClientWithBasicAuthentication("https://localhost/api", "user", "password")
res, err := client.FileCreate("pafish.exe")
if err != nil {
spew.Dump(err)
t.Fail()
}
spew.Dump(res)
}
func main() {
dropbox.Debug = true
client, err := dropbox.NewClient(dropbox.ClientOptions{
Key: config.Application.Key,
Secret: config.Application.Secret,
Token: config.BearerToken.Token,
Uid: config.BearerToken.UserId,
Root: "sandbox",
})
failIf(err)
datastoreManager := client.GetDatastoreManager()
{ // demo OpenDefaultDatastore
println("calling datastoreManager.OpenDefaultDatastore")
ds, err := datastoreManager.OpenDefaultDatastore()
failIf(err)
spew.Dump(ds)
print("\n\n")
}
{ // demo ListDatastores
println("calling datastoreManager.ListDatastores")
infos, err := datastoreManager.ListDatastores()
failIf(err)
spew.Dump(infos)
print("\n\n")
}
{ // demo DeleteDatastore
println("calling datastoreManager.DeleteDatastore")
err = datastoreManager.DeleteDatastore("default")
failIf(err)
print("\n\n")
}
{ // demo CreateDatastore and DeleteDatastore
println("calling datastoreManager.CreateDatastore")
ds, err := datastoreManager.CreateDatastore()
failIf(err)
spew.Dump(ds)
println("calling datastoreManager.DeleteDatastore")
err = datastoreManager.DeleteDatastore(ds.GetId())
failIf(err)
print("\n\n")
}
println("DatastoreManager smoke test finished!")
}
func callBackUser(id int, endpoint string) {
spew.Dump(id)
spew.Dump(endpoint)
anaconda.SetConsumerKey(CONSUMER_KEY)
anaconda.SetConsumerSecret(CONSUMER_SECRET)
api := anaconda.NewTwitterApi(ACCESS_TOKEN, ACCESS_TOKEN_SECRET)
_, err := api.PostDMToUserId(endpoint, int64(id))
//spew.Dump(message)
if err != nil {
spew.Dump(err)
}
}
func main() {
var p Point
var q Point = Point{10, 10}
r := Point{x: 100, y: 100}
spew.Dump(p, q, r)
spew.Dump(p.x, p.y, q.x, q.y, r.x, r.y)
spew.Println(distance(p, q))
spew.Println(distance(p, r))
spew.Println(distance(q, r))
}
func main() {
//* '''os.Args''' は非加工のコマンドライン引数へのアクセスを提供します。このスライスの最初の値はプログラムへのパスであり、'''os.Args[1:]''' がプログラムに対する引数を保持している点に注意してください。
argsWithProg := os.Args
argsWithoutProg := os.Args[1:]
//* あなたは通常のインデックスと同様に個々の引数を取得できます。
arg := os.Args[3] // これ引数が 2 個以下なら panic じゃん。
spew.Println(arg)
spew.Dump(argsWithProg)
spew.Dump(argsWithoutProg)
}
func main() {
a := 10
b := 20
c := [8]int{1, 2, 3, 4, 5, 6, 7, 8}
spew.Dump(a, b, c)
swap(&a, &b)
timesArray(10, &c)
spew.Dump(a, b, c)
}
func (model *NagelSchreckenberg) SimulateStep() {
var vehicle *Vehicle
spew.Dump(model)
for i, zone := range model.zones {
vehicle = zone.vehicle
if vehicle != nil {
// Step 1: Increase velocity by a unit
if vehicle.velocity < model.maxSpeed {
vehicle.velocity++
}
// Step 2: If velocity > distance to next car,
// reduce velocity by a unit to avoid collision.
y := i + 1
for model.zones[y].vehicle == nil {
if y == len(model.zones)-1 {
y = 0
} else {
y++
}
}
if vehicle.velocity >= (y - i) {
vehicle.velocity--
}
// Step 3: if velocity > 0 decrease with probability pDecrease
randGen := rand.New(rand.NewSource(time.Now().UnixNano()))
p := randGen.Float64()
if p <= model.pDecrease && vehicle.velocity > 0 {
vehicle.velocity--
}
}
}
fmt.Println()
spew.Dump(model)
fmt.Println()
// Step 4: All vehicles move ahead by their velocity in parallel
for i, zone := range model.zones {
vehicle = zone.vehicle
if vehicle == nil {
continue
}
moveTo := i + vehicle.velocity
if moveTo > len(model.zones)-1 {
moveTo = moveTo - len(model.zones)
}
if moveTo > 0 {
model.zones[moveTo].vehicle = vehicle
model.zones[i].vehicle = nil
}
}
spew.Dump(model)
fmt.Println()
}
func main() {
fileSet := token.NewFileSet()
astFile, err := parser.ParseFile(fileSet, os.Args[1], nil, parser.ParseComments)
if err != nil {
panic(err)
}
spew.Config.ContinueOnMethod = true
spew.Dump(fileSet)
fmt.Println()
fmt.Println()
fmt.Println()
spew.Dump(astFile)
}
func (c *MediaController) GetStatus(timeout time.Duration) ([]*MediaStatus, error) {
spew.Dump("getting media Status")
message, err := c.channel.Request(&getMediaStatus, timeout)
if err != nil {
return nil, fmt.Errorf("Failed to get receiver status: %s", err)
}
spew.Dump("got media Status", message)
return c.onStatus(message)
}
func main() {
m := 10
n := 20
var p *int = &m
var q *int = &n
spew.Dump(m, p, n, q)
*p = 100
spew.Dump(m, p)
fmt.Println(p == q)
fmt.Println(p != q)
}
func main() {
client := &userstream.Client{
ConsumerKey: CONSUMER_KEY,
ConsumerSecret: CONSUMER_SECRET,
AccessToken: ACCESS_TOKEN,
AccessTokenSecret: ACCESS_TOKEN_SECRET,
}
client.UserStream(func(event interface{}) {
spew.Dump(event)
switch event.(type) {
case *twitter.Tweet:
tweet := event.(*twitter.Tweet)
fmt.Printf("%s: %s\n", tweet.User.ScreenName, tweet.Text)
case *userstream.Delete:
tweetDelete := event.(*userstream.Delete)
fmt.Printf("[delete] %d\n", tweetDelete.Id)
case *userstream.Favorite:
favorite := event.(*userstream.Favorite)
fmt.Printf("[favorite] %s => %s : %s\n",
favorite.Source.ScreenName, favorite.Target.ScreenName, favorite.TargetObject.Text)
case *userstream.Unfavorite:
unfavorite := event.(*userstream.Unfavorite)
fmt.Printf("[unfavorite] %s => %s : %s\n",
unfavorite.Source.ScreenName, unfavorite.Target.ScreenName, unfavorite.TargetObject.Text)
case *userstream.Follow:
follow := event.(*userstream.Follow)
fmt.Printf("[follow] %s => %s Id:%d\n", follow.Source.ScreenName, follow.Target.ScreenName, follow.Target.Id)
// time.Sleep(time.Millisecond * 6000)
user, er := client.FollowUserId(follow.Source.Id)
if er != nil {
spew.Dump(er)
} else {
spew.Dump(user)
}
case *userstream.Unfollow:
unfollow := event.(*userstream.Unfollow)
fmt.Printf("[unfollow] %s => %s\n", unfollow.Source.ScreenName, unfollow.Target.ScreenName)
case *userstream.ListMemberAdded:
listMemberAdded := event.(*userstream.ListMemberAdded)
fmt.Printf("[list_member_added] %s (%s)\n",
listMemberAdded.TargetObject.FullName, listMemberAdded.TargetObject.Description)
case *userstream.ListMemberRemoved:
listMemberRemoved := event.(*userstream.ListMemberRemoved)
fmt.Printf("[list_member_removed] %s (%s)\n",
listMemberRemoved.TargetObject.FullName, listMemberRemoved.TargetObject.Description)
case *userstream.Record:
//process(event)
}
})
}
func (c *wscon) ReadPump() {
defer c.Unregister()
// c.ws.SetReadLimit(maxMessageSize)
// c.ws.SetReadDeadline(time.Now().Add(pongWait))
// c.ws.SetPongHandler(func(string) error { c.ws.SetReadDeadline(time.Now().Add(pongWait)); return nil })
for {
var r io.Reader
op, r, err := c.ws.NextReader()
if err != nil {
fmt.Println("cant go further")
fmt.Println(err.Error())
break
}
message, err := ioutil.ReadAll(r)
switch op {
case websocket.TextMessage:
var s p2psession
if err = json.Unmarshal(message, &s); err != nil {
fmt.Println(err.Error())
fmt.Println("Failed to decode json: ", message)
break
}
s.ID = uuid.NewV4().String()
s.ID = "foo"
s.ws = c
s.createdAt = time.Now()
api.sessions[s.ID] = s
m := &p2pmsg{
ID: s.ID,
Msg: "created",
}
spew.Dump(s)
spew.Dump(m)
data, _ := json.Marshal(m)
c.write(websocket.TextMessage, data)
case websocket.BinaryMessage:
fmt.Println("Ignoring binary message")
default:
fmt.Println("other")
}
}
}
func Demo() {
dbh, err := NewMemoryDBHandle("testing", true)
if err != nil {
glog.Fatalf("Error: %s", err)
}
dbh.ORM.Begin()
p1 := Person{
Name: "apw",
}
created, id, err := dbh.ORM.ReadOrCreate(&p1, "Name")
if err != nil {
glog.Fatal(err)
}
if created {
fmt.Println("New Insert an object. Id:", id)
} else {
fmt.Println("Get an object. Id:", id)
}
spew.Dump(p1)
n1 := Note{
Person: &p1,
Text: "testing\nfoo",
Category: "test",
}
_, err = dbh.ORM.Insert(&n1)
if err != nil {
glog.Fatal(err)
}
spew.Dump(n1)
dbh.ORM.Commit()
fmt.Println("**********************************")
p := Person{Id: p1.Id}
err = dbh.ORM.Read(&p)
if err != nil {
glog.Fatal(err)
}
dbh.ORM.LoadRelated(&p, "Notes")
spew.Dump(p.Notes)
for _, n := range p.Notes {
fmt.Printf("Note: %s - %s", p.Name, n.Text)
}
}
// MAIN_START OMIT
func main() {
motoX := &Phone{
Model: "Moto X",
Hardware: Hardware{Memory: 16, Ram: 2, NFC: true},
OS: OS{Type: "Android", Version: "5.0.0"}}
iphone6 := &Phone{
Model: "iPhone 6",
Hardware: Hardware{Memory: 16, Ram: 1, NFC: false},
OS: OS{Type: "iOS", Version: "9.0.0"}}
spew.Dump(motoX)
spew.Dump(iphone6)
}
